/******************************************************************************
 * Copyright (c) 2000-2021 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
 *
 * Contributors:
 *   Balasko, Jeno
 *   Baranyi, Botond
 *   Forstner, Matyas
 *   Kovacs, Ferenc
 *   Raduly, Csaba
 *   Szabados, Kristof
 *   Szabo, Janos Zoltan – initial implementation
 *
 ******************************************************************************/
module TenumOper {
// ********** Type definitions  *********************
type component emptyComponent {};
type enumerated myenum1 {xx1,xx2,xx3};
type enumerated myenum2 {xx3,xx4,xx5};  // reuse identifiers
type enumerated myenum3 {xx6(2),xx7(4),xx8(1)};  // with numbers
type enumerated myenum4 {xx9,xx10(3),xx11};	// partly with numbers

type myenum1 myenumSubtype1 (xx1)
type myenum1 myenumSubtype2

type record myrecord {
  myenum1 e1 optional,
  myenum3 e3
}

type record of myenum4 myrecordof;

// *************** Constanst ***********************
const myenum1 cg_1:= xx2;
const myenumSubtype1 cg_mye1 := xx1

template myenum1 t_mye1 := cg_mye1
template myenum1 t_mye2 := xx1
template myenumSubtype1 t_mye3 := xx1

modulepar myenumSubtype1 tsp_mod1 := xx1

testcase tc_enumAssign() runs on emptyComponent{
    var myenum1 vl1:= xx1;
    var myenum1 vl2;
    vl2:= xx2;
    if (vl1==xx1) {setverdict(pass);}	//at declaration
    else {setverdict(fail);}
    if (vl2==xx2) {setverdict(pass);}	//later
    else {setverdict(fail);}
}

testcase tc_enumConst() runs on emptyComponent{
    const myenum1 cl_1:=xx1;
    if (cg_1==xx2) {setverdict(pass);}	//definition part
    else {setverdict(fail);}
    if (cl_1==xx1) {setverdict(pass);}	//testcase
    else {setverdict(fail);}
}

testcase tc_enumCompEq() runs on emptyComponent {
    var myenum1 vl1,vl2,vl3;
    var myenum2 vl4;
    vl1:=xx1;
    vl2:=xx1;
    vl3:=xx3;
    vl4:=xx3;
    if (vl1==vl2) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (not(vl3==vl2)) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (vl1==xx1) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (not(vl1==xx2)) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (xx1==vl1) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
    if (not(xx3==vl1)) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
}

testcase tc_enumCompNotEq() runs on emptyComponent
{ var myenum1 vl1,vl2,vl3;
    var myenum2 vl4
    vl1:=xx1;
    vl2:=xx3;
    vl3:=xx1;
    vl4:=xx3;
    if (vl1!=vl2) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (not(vl1!=vl3)) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (vl1!=xx2) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (not(vl1!=xx1)) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (xx2!=vl2) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
    if (not(xx3!=vl2)) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
}

testcase tc_enumCompLess() runs on emptyComponent
{ var myenum1 vl1,vl2,vl3;
    vl1:=xx1;
    vl2:=xx1;
    vl3:=xx2;
    if (vl1<vl3) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (not(vl1<vl2)) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (not(vl3<vl1)) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (vl1<xx2) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (not(vl1<xx1)) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (not(vl3<xx1)) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (xx1<vl3) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
    if (not(xx1<vl2)) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
    if (not(xx2<vl1)) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
}

testcase tc_enumCompLessEq() runs on emptyComponent
{ var myenum1 vl1,vl2,vl3;
    vl1:=xx1;
    vl2:=xx1;
    vl3:=xx2;
    if (vl1<=vl3) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (vl1<=vl2) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (not(vl3<=vl1)) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (vl1<=xx2) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (vl1<=xx1) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (not(vl3<=xx1)) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (xx1<=vl3) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
    if (xx1<=vl2) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
    if (not(xx2<=vl1)) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
}

testcase tc_enumCompGreat() runs on emptyComponent
{ var myenum1 vl1,vl2,vl3;
    vl1:=xx1;
    vl2:=xx1;
    vl3:=xx2;
    if (vl3>vl1) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (not(vl1>vl2)) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (not(vl1>vl3)) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (vl3>xx1) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (not(vl1>xx1)) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (not(vl2>xx2)) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (xx2>vl1) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
    if (not(xx1>vl2)) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
    if (not(xx1>vl3)) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
}

testcase tc_enumCompGreatEq() runs on emptyComponent
{ var myenum1 vl1,vl2,vl3;
    vl1:=xx1;
    vl2:=xx1;
    vl3:=xx2;
    if (vl3>=vl1) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (vl1>=vl2) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (not(vl1>=vl3)) {setverdict(pass);}	//variable_variable
    else {setverdict(fail);}
    if (vl3>=xx1) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (vl1>=xx1) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (not(vl2>=xx2)) {setverdict(pass);}	//variable_value
    else {setverdict(fail);}
    if (xx2>=vl1) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
    if (xx1>=vl2) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
    if (not(xx1>=vl3)) {setverdict(pass);}	//value_variable
    else {setverdict(fail);}
}

// in the number tests the automatic choice of numbers counts.
testcase tc_enumNumb1() runs on emptyComponent
{ var myenum1 vl1,vl2,vl3;  // automatic numbers
    vl1:=xx1;
    vl2:=xx2;
    vl3:=xx3;
    if (vl1<vl2) {setverdict(pass);}
    else {setverdict(fail);}
    if (vl2<vl3) {setverdict(pass);}
    else {setverdict(fail);}
}

testcase tc_enumNumb2() runs on emptyComponent
{ var myenum3 vl1,vl2,vl3;  // manual numbers
    vl1:=xx6; //2
    vl2:=xx7; //4
    vl3:=xx8; //1
    if (vl3<vl1) {setverdict(pass);}
    else {setverdict(fail);}
    if (vl1<vl2) {setverdict(pass);}
    else {setverdict(fail);}
}

testcase tc_enumNumb3() runs on emptyComponent
{ var myenum4 vl1,vl2,vl3;  // semi-automatic numbers
    vl1:=xx9; //0 - automatic
    vl2:=xx10; //3 - manual
    vl3:=xx11; //1 - automatic
    if (vl1<vl3) {setverdict(pass);}
    else {setverdict(fail);}
    if (vl3<vl2) {setverdict(pass);}
    else {setverdict(fail);}
}

function f_enumReturn() return myenumSubtype1
{
    var template myenumSubtype2 vt_mye1 := xx1
    var myenumSubtype2 vl_mye1 := xx1
    var myenumSubtype2 vl_myenumSubtype1 := valueof(t_mye1)
    var myenumSubtype2 vl_myenumSubtype2 := cg_mye1
    if (cg_mye1 == valueof(vt_mye1)) { return cg_mye1 }
    else { return valueof(vt_mye1) }
    if (vl_mye1 == vl_myenumSubtype1 and vl_myenumSubtype1 == vl_myenumSubtype2) { return valueof(t_mye1) }
    else { return cg_mye1 }
}

testcase tc_enumSubtypes() runs on emptyComponent
{
    if (f_enumReturn() == xx1) { setverdict(pass) }
    else { setverdict(fail) }
}

testcase tc_enumIsvalue() runs on emptyComponent
{
  var myenum1 x1 := xx1, x2;
  template myenum1 subenum := (xx1,xx2);
  template myenum1 every := ?;
  template myenum1 actual := xx1;

  if ( isvalue(x1) ) { setverdict(pass); } else { setverdict(fail); };
  if ( isvalue(x2) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(subenum) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(every) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(actual) ) { setverdict(pass); } else { setverdict(fail); };

  if ( isvalue(myenum1 : ( xx1 )) ) { setverdict(pass); } else { setverdict(fail); };
  if ( isvalue(myenum1 : ( xx1, xx2 )) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(myenum1 : *) ) { setverdict(fail); } else { setverdict(pass); };

  if ( isvalue(modifies actual := xx2) ) { setverdict(pass); } else { setverdict(fail); };
  if ( isvalue(modifies actual := *) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(modifies subenum := xx2) ) { setverdict(pass); } else { setverdict(fail); };
}

testcase tc_int2enum() runs on emptyComponent
{
  var myenum1 e1 := xx1;
  var myenum2 e2;
  var integer i := 2;
  var myrecord rec1 := { e1 := omit, e3 := xx7 };
  var myrecord rec2;
  var myrecordof recof1 := { xx10, xx11 };
  var myrecordof recof2 := { xx9 };
  
  int2enum(1, e1);
  int2enum(i, e2);
  int2enum(5 - 3, rec1.e3);
  int2enum(lengthof(recof1), rec1.e1);
  int2enum(enum2int(cg_1), rec2.e3);
  int2enum(1 + str2int("2"), recof1[1]);
  int2enum(2 / 2, recof2[2]);
  
  if (e1 != xx2) { setverdict(fail, "e1 = ", e1); }
  if (e2 != xx5) { setverdict(fail, "e2 = ", e2); }
  if (rec1 != { e1 := xx3, e3 := xx6 }) { setverdict(fail, "rec1 = ", rec1) };
  if (log2str(rec2) != "{ e1 := <unbound>, e3 := xx8 (1) }") { setverdict(fail, "rec2 = ", rec2); }
  if (recof1 != { xx10, xx10 }) { setverdict(fail, "recof1 = ", recof1); }
  if (log2str(recof2) != "{ xx9 (0), <unbound>, xx11 (1) }") { setverdict(fail, "recof2 = ", recof2); }
  setverdict(pass);
}

control {
    const myenum1 cl_1 := xx1; // can constants be declared in the control part
    const myenum2 cl_2 := xx3;
    const myenum3 cl_3 := xx6;
    const myenum4 cl_4 := xx9;
    var myenum1 vl_1; // can variable be declared in the control part
    var myenum2 vl_2;
    var myenum3 vl_3;
    var myenum4 vl_4;

    execute(tc_enumAssign());
    execute(tc_enumConst());
    execute(tc_enumCompEq());
    execute(tc_enumCompNotEq());
    execute(tc_enumCompLess());
    execute(tc_enumCompLessEq());
    execute(tc_enumCompGreat());
    execute(tc_enumCompGreatEq());
    execute(tc_enumNumb1());
    execute(tc_enumNumb2());
    execute(tc_enumNumb3());
    execute(tc_enumSubtypes());
    execute(tc_enumIsvalue());
    execute(tc_int2enum());
}
}