/******************************************************************************
 * Copyright (c) 2000-2016 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
 *
 * Contributors:
 *   Balasko, Jeno
 *   Godar, Marton
 *   Kovacs, Ferenc
 *   Raduly, Csaba
 *   Szabados, Kristof
 *   Szabo, Janos Zoltan – initial implementation
 *
 ******************************************************************************/
module TverdictOper
{ type component verdictOper_mycomp {};
  const verdicttype verdictOper_const1:=fail;

testcase verdictAssign() runs on verdictOper_mycomp {
 var verdicttype x1:=inconc;
 var verdicttype x2;
 x2:=pass;
 if (x1==inconc) {setverdict(pass);}	//at declaration
     else {setverdict(fail);}
 if (x2==pass) {setverdict(pass);}	//later
     else {setverdict(fail);}
}

testcase verdictConst() runs on verdictOper_mycomp {
 const verdicttype const1:=inconc;
 if (verdictOper_const1==fail) {setverdict(pass);}	//definition part declaration
     else {setverdict(fail);}
 if (const1==inconc) {setverdict(pass);}	//testcase
     else {setverdict(fail);}
}


testcase verdictCompEq() runs on verdictOper_mycomp {
var verdicttype x1,x2,x3;
  x1:=pass;
  x2:=pass;
  x3:=inconc;
  if (x1==x2) {setverdict(pass);}	//variable_variable
   else {setverdict(fail);}
  if (not(x3==x2)) {setverdict(pass);}	//variable_variable
   else {setverdict(fail);}
  if (x1==pass) {setverdict(pass);}	//variable_value
   else {setverdict(fail);}
  if (not(x1==fail)) {setverdict(pass);}	//variable_value
   else {setverdict(fail);}
  if (pass==x1) {setverdict(pass);}	//value_variable
   else {setverdict(fail);}
  if (not(inconc==x1)) {setverdict(pass);}	//value_variable
   else {setverdict(fail);}
  if (pass==pass) {setverdict(pass);}	//value_value
   else {setverdict(fail);}
  if (not(pass==fail)) {setverdict(pass);}	//value_value
   else {setverdict(fail);}
}

testcase verdictCompNotEq() runs on verdictOper_mycomp
{ var verdicttype x1,x2,x3;
  x1:=pass;
  x2:=fail;
  x3:=pass;
  if (x1!=x2) {setverdict(pass);}	//variable_variable
   else {setverdict(fail);}
  if (not(x1!=x3)) {setverdict(pass);}	//variable_variable
   else {setverdict(fail);}
  if (x1!=fail) {setverdict(pass);}	//variable_value
   else {setverdict(fail);}
  if (not(x1!=pass)) {setverdict(pass);}	//variable_value
   else {setverdict(fail);}
  if (pass!=x2) {setverdict(pass);}	//value_variable
   else {setverdict(fail);}
  if (not(fail!=x2)) {setverdict(pass);}	//value_variable
   else {setverdict(fail);}
  if (inconc!=fail) {setverdict(pass);}	//value_value
   else {setverdict(fail);}
  if (not(pass!=pass)) {setverdict(pass);}	//value_value
   else {setverdict(fail);}
}

testcase verdictSetGet() runs on verdictOper_mycomp {
 var verdicttype x1;
 if (getverdict != none) { setverdict(fail); stop; }
 setverdict(pass);
 x1 := getverdict;
 if (x1 != pass) { setverdict(fail); stop; }
}

testcase verdictSet_None() runs on verdictOper_mycomp {
 // do nothing
}

testcase verdictSet_n_None() runs on verdictOper_mycomp {
 setverdict(none);
}

testcase verdictSet_p_Pass() runs on verdictOper_mycomp {
 setverdict(pass);
}

testcase verdictSet_i_Inconc() runs on verdictOper_mycomp {
 setverdict(inconc);
}

testcase verdictSet_f_Fail() runs on verdictOper_mycomp {
 setverdict(fail, "fail alone is fail");
}

testcase verdictSet_p_i_Inconc() runs on verdictOper_mycomp {
 setverdict(pass);
 setverdict(inconc);
}

testcase verdictSet_p_f_Fail() runs on verdictOper_mycomp {
 setverdict(pass);
 setverdict(fail, "fail after pass is fail");
}

testcase verdictSet_p_n_Pass() runs on verdictOper_mycomp {
 setverdict(pass);
 setverdict(none);
}

testcase verdictSet_i_p_Inconc() runs on verdictOper_mycomp {
 setverdict(inconc);
 setverdict(pass);
}

testcase verdictSet_i_f_Fail() runs on verdictOper_mycomp {
 setverdict(inconc);
 setverdict(fail);
}

testcase verdictSet_i_n_Inconc() runs on verdictOper_mycomp {
 setverdict(inconc);
 setverdict(none);
}

testcase verdictSet_f_p_Fail() runs on verdictOper_mycomp {
 setverdict(fail);
 setverdict(pass, "pass after fail is still fail");
}

testcase verdictSet_f_i_Fail() runs on verdictOper_mycomp {
 setverdict(fail);
 setverdict(inconc);
}

testcase verdictSet_f_n_Fail() runs on verdictOper_mycomp {
 setverdict(fail);
 setverdict(none);
}

testcase verdictSet_n_p_Pass() runs on verdictOper_mycomp {
 setverdict(none);
 setverdict(pass);
}

testcase verdictSet_n_i_Inconc() runs on verdictOper_mycomp {
 setverdict(none);
 setverdict(inconc);
}

testcase verdictSet_n_f_Fail() runs on verdictOper_mycomp {
 setverdict(none);
 setverdict(fail);
}

/*--- VERDICT REASON -----------------------------------------------*/

modulepar octetstring VR_mp := '12353425'O;
const float VR_fl := 1.0;
type record VR_rec {
	integer i,
	boolean b
}

testcase verdict_reason() runs on verdictOper_mycomp {

	template VR_rec VR_tmpl := { i := 1235, b := true};
	var integer VR_int := 5;
	var boolean VR_bool;
	timer VR_timer := 5.0;
	VR_timer.start;

 	setverdict(pass, "Module parameter identifier: ", VR_mp);
 	setverdict(pass, "Literal value: ", "this is the value");
 	setverdict(pass, "Data constant identifier: ", VR_fl);
 	setverdict(pass, "Template instance: ", VR_tmpl);
 	setverdict(pass, "Data type variable identifier: ", VR_int);
 	setverdict(pass, "Uninitialized data type variable identifier: ", VR_bool);
 	setverdict(pass, "self component type variable identifier: ", self);
 	setverdict(pass, "mtc component type variable identifier: ", mtc);
 	setverdict(pass, "system component type variable identifier: ", system);
 	setverdict(pass, "Timer running operation: ", VR_timer.running);
 	setverdict(pass, "Timer name: ", VR_timer);
 	setverdict(pass, "Getverdict operation: ", getverdict);
 	setverdict(pass, "More parameters: ", getverdict, system, self, VR_tmpl, VR_mp, "and this is the and of all logging...");
 	setverdict(pass);
}

type verdicttype typedefbasic_myverdt;
type verdicttype myv1 (pass, fail, none, inconc)
type myv1 myv2
type verdicttype myv3 (error)
type verdicttype myv4 (myv1, myv3)
const myv1 c_myv1 := pass
const myv4 c_myv2 := none
template myv1 t_myv1 := f_v1()
template myv1 t_myv2 := f_v2()
template myv4 t_myv3 := fail

modulepar myv1 mod1 := c_myv1

function f_v1() return myv1 { return inconc }
function f_v2() return myv1 { return c_myv1 }

testcase verdictSubtypes() runs on verdictOper_mycomp {
  if (pass == mod1 and mod1 == pass and f_v1() != f_v2()) { setverdict(pass) }
  else { setverdict(fail) }
  var template myv3 vt_v1 := error
  var myv3 v_v1 := valueof(vt_v1)
  if (error == v_v1 and match(error, vt_v1)) { setverdict(pass) }
  else { setverdict(fail) }
}

testcase verdictIsbound() runs on verdictOper_mycomp {
  var verdicttype v0;
  var verdicttype v1 := pass;
  if ( isvalue(v0) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(v1) ) { setverdict(pass); } else { setverdict(fail); };
}

control{
 var integer fault_count := 0;
 if (execute(verdictAssign()) != pass) {
  log("Test case verdictAssign has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictConst()) != pass) {
  log("Test case verdictConst has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictCompEq()) != pass) {
  log("Test case verdictCompEq has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictCompNotEq()) != pass) {
  log("Test case verdictCompNotEq has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSetGet()) != pass) {
  log("Test case verdictSetGet has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_None()) != none) {
  log("Test case verdictSet_None has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_n_None()) != none) {
  log("Test case verdictSet_n_None has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_p_Pass()) != pass) {
  log("Test case verdictSet_p_Pass has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_i_Inconc()) != inconc) {
  log("Test case verdictSet_i_Inconc has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_f_Fail()) != fail) {
  log("Test case verdictSet_f_Fail has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_p_i_Inconc()) != inconc) {
  log("Test case verdictSet_p_i_Inconc has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_p_f_Fail()) != fail) {
  log("Test case verdictSet_p_f_Fail has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_p_n_Pass()) != pass) {
  log("Test case verdictSet_p_n_Pass has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_i_p_Inconc()) != inconc) {
  log("Test case verdictSet_i_p_Inconc has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_i_f_Fail()) != fail) {
  log("Test case verdictSet_i_f_Fail has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_i_n_Inconc()) != inconc) {
  log("Test case verdictSet_i_n_Inconc has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_f_p_Fail()) != fail) {
  log("Test case verdictSet_f_p_Fail has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_f_i_Fail()) != fail) {
  log("Test case verdictSet_f_i_Fail has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_f_n_Fail()) != fail) {
  log("Test case verdictSet_f_n_Fail has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_n_p_Pass()) != pass) {
  log("Test case verdictSet_n_p_Pass has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_n_i_Inconc()) != inconc) {
  log("Test case verdictSet_n_i_Inconc has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSet_n_f_Fail()) != fail) {
  log("Test case verdictSet_n_f_Fail has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdict_reason()) != pass) {
  log("Test case verdict_reason has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (execute(verdictSubtypes()) != pass) {
  log("Test case verdictSubtypes() has unexpected verdict.");
  fault_count := fault_count + 1;
  }
 if (execute(verdictIsbound()) != pass) {
  log("Test case verdictSubtypes() has unexpected verdict.");
  fault_count := fault_count + 1;
 }
 if (fault_count == 0) {
  log("ALL TEST CASES HAVE PASSED!!!");
 } else {
  var integer i := 0;
  log("NUMBER OF FAILED TEST CASES: ", fault_count);
  // this will cause an error
  i := 1 / i;
 }
 }
}