/******************************************************************************
 * 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
 *   Beres, Szabolcs
 *   Godar, Marton
 *   Kovacs, Ferenc
 *   Raduly, Csaba
 *   Szabados, Kristof
 *   Szabo, Janos Zoltan – initial implementation
 *
 ******************************************************************************/
module TsetofOper {
// ********** Type definitions  *********************
type component setofOper_mycomp {};
type enumerated setofOper_myenum {xx1,xx2,xx3};
type record setofOper_trecord {
  integer x1 optional,
  float x2 };
type record of octetstring setofOper_trecof;
type set setofOper_tset {
  integer x1,
  float x2 optional };
type set of charstring setofOper_tsetof;
type union setofOper_tunion {
  integer x1,
  float x2 };
type set of integer setofOper_mysetof1; 	// set of basic types
type set of setofOper_myenum setofOper_mysetof2; // set of enum
type set of setofOper_trecord setofOper_mysetof3;  // set of record
type set of setofOper_trecof setofOper_mysetof4; // set of record of
type set of setofOper_tset setofOper_mysetof5;  // set of set
type set of setofOper_tsetof setofOper_mysetof6; // set of set of
type set of setofOper_tunion setofOper_mysetof7; // set of union
// *************** Constanst ***********************
const setofOper_trecord setofOper_temp1:={ x1:=omit, x2:=3.4 };
const setofOper_trecof setofOper_temp2:={ 'AF12'O };
const setofOper_tset setofOper_temp3:={ x1:=234, x2:=1.9};
const setofOper_tsetof setofOper_temp4:={"f","8"};
const setofOper_tunion setofOper_temp5:={ x2:=1.3 };
const setofOper_mysetof1 setofOper_const1:={ 1,2 }	//set of basic types
const setofOper_mysetof2 setofOper_const2:={ xx2, xx1 }
const setofOper_mysetof3 setofOper_const4:={   //set of record
  { x1:=1, x2:=1.2 },setofOper_temp1 };
const setofOper_mysetof4 setofOper_const6:={   //set of record of
  { '12AB'O, 'CD12'O },  setofOper_temp2 };
const setofOper_mysetof5 setofOper_const8:={   //set of set
  { x1:=2, x2:=1.3}, setofOper_temp3 };
const setofOper_mysetof6 setofOper_const10:={   //set of set of
  {"a","b"}, setofOper_temp4 }; //{"f","8"},
const setofOper_mysetof7 setofOper_const12:={   //set of union
  { x1 :=3 }, setofOper_temp5  }; //{ x2:=1.3 }

testcase setofAssign() runs on setofOper_mycomp{
  var setofOper_mysetof1 x1:={ 12,34} 	//set of basic types
  var setofOper_mysetof1 x2,x3,x4;
  x2:={ 32, 12 };
  x3:={32};
  x3:={32,12};
  x4:={};
  if (x1[0]==12) {setverdict(pass);}	//at declaration
  else {setverdict(fail);}
  if (x1[1]==34) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0]==32) {setverdict(pass);}	//later
  else {setverdict(fail);}
  if (x2[1]==12) {setverdict(pass);}
  else {setverdict(fail);}
  if (x3[0]==32) {setverdict(pass);}	//later, change of size
  else {setverdict(fail);}
  if (x3[1]==12) {setverdict(pass);}
  else {setverdict(fail);}
  //if (x4=={}) {setverdict(pass);}		// empty set of
  //     else {setverdict(fail);}
}

testcase setofAssignEnum() runs on setofOper_mycomp{
  var setofOper_mysetof2 x1:={ xx2 }	//set of enum
  var setofOper_mysetof2 x2;
  x2:={xx2,xx1};
  //at declaration
  if (x1[0]==xx2) {setverdict(pass);}
  else {setverdict(fail);}
  //later
  if (x2[0]==xx2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1]==xx1) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofAssignRec() runs on setofOper_mycomp{
  var setofOper_trecord temp1:={ x1:=omit, x2:=3.4 };
  var setofOper_mysetof3 x1:={   //set of record
    { x1:=1, x2:=1.2 }, temp1 };
  var setofOper_mysetof3 x2;
  x2:={ { x1:=1, x2:=1.2 }, temp1 };
  if (x1[0].x1==1) {setverdict(pass);}	//at declaration
  else {setverdict(fail);}
  if (x1[0].x2==1.2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1]==temp1) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0].x1==1) {setverdict(pass);}	//later
  else {setverdict(fail);}
  if (x2[0].x2==1.2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ispresent(x2[1].x1))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1].x2==3.4) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofAssignRecof() runs on setofOper_mycomp{
  var setofOper_trecof temp2:={'AF12'O};
  var setofOper_mysetof4 x1:={   //set of record of
    { '12AB'O, 'CD12'O }, temp2 };
  var setofOper_mysetof4 x2;
  x2:={ { '12AB'O, 'CD12'O }, temp2 };
  if (x1[0][0]=='12AB'O) {setverdict(pass);}	//at declaration
  else {setverdict(fail);}
  if (x1[0][1]=='CD12'O) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1]==temp2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0][0]=='12AB'O) {setverdict(pass);}	//later
  else {setverdict(fail);}
  if (x2[0][1]=='CD12'O) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1][0]=='AF12'O) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofAssignSet() runs on setofOper_mycomp{
  var setofOper_tset temp1:={ x1:=2, x2:=omit };
  var setofOper_mysetof5 x1:={   //set of set
    { x1:=1, x2:=1.2 }, temp1 };
  var setofOper_mysetof5 x2;
  x2:={ { x1:=1, x2:=1.2 }, temp1 };
  if (x1[0].x1==1) {setverdict(pass);}	//at declaration
  else {setverdict(fail);}
  if (x1[0].x2==1.2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1]==temp1) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0].x1==1) {setverdict(pass);}	//later
  else {setverdict(fail);}
  if (x2[0].x2==1.2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1].x1==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ispresent(x2[1].x2))) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofAssignSetof() runs on setofOper_mycomp{
  var setofOper_tsetof temp2:={"a","7"};
  var setofOper_mysetof6 x1:={   //set of set of
    { "1", "a" }, temp2 };
  var setofOper_mysetof6 x2;
  x2:={ { "1", "a" }, temp2 };
  if (x1[0][0]=="1") {setverdict(pass);}	//at declaration
  else {setverdict(fail);}
  if (x1[0][1]=="a") {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1]==temp2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0][0]=="1") {setverdict(pass);}	//later
  else {setverdict(fail);}
  if (x2[0][1]=="a") {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1][0]=="a") {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1][1]=="7") {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofAssignUnion() runs on setofOper_mycomp{
  var setofOper_tunion temp5 := {x2:=1.3}
  var setofOper_mysetof7 x1:={   //set of union
    { x1 :=3 }, temp5  }; //{ x2:=1.3
  var setofOper_mysetof7 x2;
  x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
  if (x1[0].x1==3) {setverdict(pass);}	//at declaration
  else {setverdict(fail);}
  if (ischosen(x1[0].x1)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(x1[0].x2))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1]==temp5) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0].x1==3) {setverdict(pass);}	//later
  else {setverdict(fail);}
  if (ischosen(x2[0].x1)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(x2[0].x2))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1].x2==1.3) {setverdict(pass);}
  else {setverdict(fail);}
  if (ischosen(x2[1].x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(x2[1].x1))) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofAssignElem() runs on setofOper_mycomp{
  var setofOper_mysetof1 x1,x2,x3,x4,x5;	//set of basic types
  x1:={ 3, 2 };
  x2:={ 1, 2 };
  x3:=x2;
  x4:=x2;
  x5:={2};
  x2[0]:=3;			//change element to value
  x3[0]:=x1[0];			//change element to element
  x4[2]:=2;			// add element
  x5[2]:=3;			// out of order
  if (x1[1]==2) {setverdict(pass);}	//accessing individual element
  else {setverdict(fail);}
  if (x2[0]==3) {setverdict(pass);}	// change element to value
  else {setverdict(fail);}
  if (x2[1]==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x3[0]==3) {setverdict(pass);}	// change element to element
  else {setverdict(fail);}
  if (x3[1]==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4[0]==1) {setverdict(pass);}	// add element
  else {setverdict(fail);}
  if (x4[1]==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4[2]==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x5[2]==3) {setverdict(pass);}	// out of order
  else {setverdict(fail);}
}

testcase setofAssignElemEnum() runs on setofOper_mycomp{
  var setofOper_mysetof2 x1:={ xx1, xx2 };	//set of enumerated
  var setofOper_mysetof2 x2, x3;
  x2:={ xx1, xx2 }
  x1[0]:=xx3;			//change element
  x2[2]:=xx3;			// add element
  x3[2]:=xx3;			// out of order
  if (x1[0]==xx3) {setverdict(pass);}	// change element
  else {setverdict(fail);}
  if (x1[1]==xx2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0]==xx1) {setverdict(pass);}	// add element
  else {setverdict(fail);}
  if (x2[1]==xx2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[2]==xx3) {setverdict(pass);}
  else {setverdict(fail);}
  if (x3[2]==xx3) {setverdict(pass);}	// out of order
  else {setverdict(fail);}
}

testcase setofAssignElemRec() runs on setofOper_mycomp{
  var setofOper_mysetof3 x1,x2,x3; 	//set of record
  x1:={   { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
  x2:=x1;
  x1[0].x1:=2;
  //temp1.x1:=3;
  x1[1].x1:=3;
  x2[2]:= {x1:=2, x2:=1.3};		// add element
  x3[1]:= {x1:=2, x2:=1.3};		//out of order
  if (x1[0].x1==2) {setverdict(pass);}	// change element
  else {setverdict(fail);}
  if (x1[0].x2==1.2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1].x1==3) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1].x2==3.4) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0].x1==1) {setverdict(pass);}	//add element
  else {setverdict(fail);}
  if (x2[0].x2==1.2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ispresent(x2[1].x1))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1].x2==3.4) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[2].x1==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[2].x2==1.3) {setverdict(pass);}
  else {setverdict(fail);}
  if (x3[1].x1==2) {setverdict(pass);}	   // out of order
  else {setverdict(fail);}
  if (x3[1].x2==1.3) {setverdict(pass);}
  else {setverdict(fail);}
}


testcase setofAssignElemRecof() runs on setofOper_mycomp{
  var setofOper_mysetof4 x1,x2,x3;		 //set of record of
  x1:={  { '12AB'O, 'CD12'O }, { 'ABCD'O } };
  x2:=x1;
  x1[0][1]:='34AB'O;		//change element
  x2[2]:={ '1234'O};		//add element
  x3[2]:={'12CD'O};		//out of order
  if (x1[0][0]=='12AB'O) {setverdict(pass);}	// change element
  else {setverdict(fail);}
  if (x1[0][1]=='34AB'O) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1][0]=='ABCD'O) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0][0]=='12AB'O) {setverdict(pass);}	// add element
  else {setverdict(fail);}
  if (x2[0][1]=='CD12'O) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1][0]=='ABCD'O) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[2][0]=='1234'O) {setverdict(pass);}
  else {setverdict(fail);}
  if (x3[2][0]=='12CD'O) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
}

testcase setofAssignElemSet() runs on setofOper_mycomp{
  var setofOper_mysetof5 x1,x2,x3    		//set of set
  x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
  x2:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
  x1[0].x2:=3.4;				//change element
  x2[2]:={  x1:=2, x2:=1.3 };		// add element
  x3[2]:={  x1:=2, x2:=1.3 };		// out of order
  if (x1[0].x1==1) {setverdict(pass);}	//change element
  else {setverdict(fail);}
  if (x1[0].x2==3.4) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1].x1==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ispresent(x1[1].x2))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0].x1==1) {setverdict(pass);}	//add element
  else {setverdict(fail);}
  if (x2[0].x2==1.2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1].x1==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ispresent(x2[1].x2))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[2].x1==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[2].x2==1.3) {setverdict(pass);}
  else {setverdict(fail);}
  if (x3[2].x1==2) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
  if (x3[2].x2==1.3) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofAssignElemSetof() runs on setofOper_mycomp{
  var setofOper_tsetof temp2:={"a","7"};
  var setofOper_mysetof6 x1,x2,x3;   //set of set of
  x1:={ { "1" }, {"a","7"}};
  x2:={ { "1" }, {"a","7"}};
  x1[0][0]:="h";			// change element
  x2[2]:={"2"};			//add element
  x3[2]:={"2"};			//out of order
  if (x1[0][0]=="h") {setverdict(pass);}	  //change element
  else {setverdict(fail);}
  if (x1[1][0]=="a") {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1][1]=="7") {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0][0]=="1") {setverdict(pass);}	  //add element
  else {setverdict(fail);}
  if (x2[1][0]=="a") {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1][1]=="7") {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[2][0]=="2") {setverdict(pass);}
  else {setverdict(fail);}
  if (x3[2][0]=="2") {setverdict(pass);}		// out of order
  else {setverdict(fail);}
}

testcase setofAssignElemUnion() runs on setofOper_mycomp{
  var setofOper_tunion temp5 := {x2:=1.3}
  var setofOper_mysetof7 x1,x2,x3;   //set of union
  x1:={ {x1 :=3 }, {x2:=1.3} };
  x2:={ {x1 :=3 }, {x2:=1.3} };
  x1[0].x2:=3.4;			//change element
  x2[2]:={ x2:=1.4};	 	// add element
  x3[2]:={ x2:=1.4}; 		// out of order
  if (x1[0].x2==3.4) {setverdict(pass);}		//change element
  else {setverdict(fail);}
  if (ischosen(x1[0].x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(x1[0].x1))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1[1].x2==1.3) {setverdict(pass);}
  else {setverdict(fail);}
  if (ischosen(x1[1].x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(x1[1].x1))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[0].x1==3) {setverdict(pass);}		//add element
  else {setverdict(fail);}
  if (ischosen(x2[0].x1)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(x2[0].x2))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[1].x2==1.3) {setverdict(pass);}
  else {setverdict(fail);}
  if (ischosen(x2[1].x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(x2[1].x1))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x2[2].x2==1.4) {setverdict(pass);}
  else {setverdict(fail);}
  if (ischosen(x2[2].x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(x2[2].x1))) {setverdict(pass);}
  else {setverdict(fail);}
  if (x3[2].x2==1.4) {setverdict(pass);}		//out of order
  else {setverdict(fail);}
  if (ischosen(x3[2].x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(x3[2].x1))) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofConst() runs on setofOper_mycomp{
  const setofOper_mysetof1 const1:={1,2,3} //set of basic types
  if (setofOper_const1[0]==1) {setverdict(pass);}	//definition part
  else {setverdict(fail);}
  if (setofOper_const1[1]==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (const1[0]==1) {setverdict(pass);}	//testcase
  else {setverdict(fail);}
  if (const1[1]==2) {setverdict(pass);}
  else {setverdict(fail);}
  if (const1[2]==3) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofConstEnum() runs on setofOper_mycomp{
  const setofOper_mysetof2 const1:={xx1,xx2,xx3} //set of enumerated
  if (setofOper_const2[0]==xx2) {setverdict(pass);}	//definition part
  else {setverdict(fail);}
  if (setofOper_const2[1]==xx1) {setverdict(pass);}
  else {setverdict(fail);}
  if (const1[0]==xx1) {setverdict(pass);}	//testcase
  else {setverdict(fail);}
  if (const1[1]==xx2) {setverdict(pass);}
  else {setverdict(fail);}
  if (const1[2]==xx3) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofConstRec() runs on setofOper_mycomp{
  const setofOper_mysetof3 const4:={   //set of record
    { x1:=1, x2:=1.2 }, setofOper_temp1 };
  if (setofOper_const4[0].x1==1) {setverdict(pass);}	//definition part
  else {setverdict(fail);}
  if (setofOper_const4[0].x2==1.2) {setverdict(pass);}
  else {setverdict(fail);}
  if (setofOper_const4[1]==setofOper_temp1) {setverdict(pass);}
  else {setverdict(fail);}
  if (const4[0].x1==1) {setverdict(pass);}	//testcase
  else {setverdict(fail);}
  if (const4[0].x2==1.2) {setverdict(pass);}
  else {setverdict(fail);}
  if (const4[1]==setofOper_temp1) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofConstRecof() runs on setofOper_mycomp{
  const setofOper_mysetof4 const6:={   //set of record of
    { '12AB'O, 'CD12'O }, setofOper_temp2 };
  if (setofOper_const6[0][0]=='12AB'O) {setverdict(pass);}	//definition part
  else {setverdict(fail);}
  if (setofOper_const6[0][1]=='CD12'O) {setverdict(pass);}
  else {setverdict(fail);}
  if (setofOper_const6[1]==setofOper_temp2) {setverdict(pass);}
  else {setverdict(fail);}
  if (const6[0][0]=='12AB'O) {setverdict(pass);}	//testcase
  else {setverdict(fail);}
  if (const6[0][1]=='CD12'O) {setverdict(pass);}
  else {setverdict(fail);}
  if (const6[1]==setofOper_temp2) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofConstSet() runs on setofOper_mycomp{
  const setofOper_mysetof5 const8:={   //set of set
    { x1:=2, x2:=1.3}, setofOper_temp3 };
  if (setofOper_const8[0].x1==2) {setverdict(pass);}	//definition part
  else {setverdict(fail);}
  if (setofOper_const8[0].x2==1.3) {setverdict(pass);}
  else {setverdict(fail);}
  if (setofOper_const8[1]==setofOper_temp3) {setverdict(pass);}
  else {setverdict(fail);}
  if (const8[0].x1==2) {setverdict(pass);}	//testcase
  else {setverdict(fail);}
  if (const8[0].x2==1.3) {setverdict(pass);}
  else {setverdict(fail);}
  if (const8[1]==setofOper_temp3) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofConstSetof() runs on setofOper_mycomp{
  const setofOper_mysetof6 const10:={   //set of set of
    {"a","b"}, {"f","8"} };
  if (setofOper_const10[0][0]=="a") {setverdict(pass);}	//definition part
  else {setverdict(fail);}
  if (setofOper_const10[0][1]=="b") {setverdict(pass);}
  else {setverdict(fail);}
  if (setofOper_const10[1]==setofOper_temp4) {setverdict(pass);}
  else {setverdict(fail);}
  if (const10[0][0]=="a") {setverdict(pass);}	//testcase
  else {setverdict(fail);}
  if (const10[0][1]=="b") {setverdict(pass);}
  else {setverdict(fail);}
  if (const10[1][0]=="f") {setverdict(pass);}
  else {setverdict(fail);}
  if (const10[1][1]=="8") {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofConstUnion() runs on setofOper_mycomp{
  const setofOper_mysetof7 const12:={   //set of union
    { x1 :=3 }, { x2:=1.3 } };
  if (setofOper_const12[0].x1==3) {setverdict(pass);}	//definition part
  else {setverdict(fail);}
  if (ischosen(setofOper_const12[0].x1)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(setofOper_const12[0].x2))) {setverdict(pass);}
  else {setverdict(fail);}
  if (setofOper_const12[1]==setofOper_temp5) {setverdict(pass);}
  else {setverdict(fail);}
  if (const12[0].x1==3) {setverdict(pass);}	//testcase
  else {setverdict(fail);}
  if (ischosen(const12[0].x1)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(const12[0].x2))) {setverdict(pass);}
  else {setverdict(fail);}
  if (const12[1].x2==1.3) {setverdict(pass);}
  else {setverdict(fail);}
  if (ischosen(const12[1].x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(ischosen(const12[1].x1))) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofConstComp() runs on setofOper_mycomp{
  const setofOper_mysetof1 x1:={ 1,2,3 };
  const setofOper_mysetof1 x2:={ 1,2,3 };
  const setofOper_mysetof1 x3:={ 1,2 };
  const setofOper_mysetof1 x4:={ 3,1,2 };
  if (x1==x2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1==x3)) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4==x2) {setverdict(pass);}	// out of order
  else {setverdict(fail);}
  if (x1!=x3) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1!=x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x4!=x2)) {setverdict(pass);}	// out of order
  else {setverdict(fail);}
}

testcase setofComp() runs on setofOper_mycomp{
  var setofOper_mysetof1 x1,x2,x3,x4; //set of basic types
  x1:={ 1,2,3 };
  x2:={ 1,2,3 };
  x3:={ 1,2 };
  x4:={ 3,1,2 };
  if (x1==x2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1==x3)) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4==x2) {setverdict(pass);}	// out of order
  else {setverdict(fail);}
  if (x1!=x3) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1!=x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x4!=x2)) {setverdict(pass);}	// out of order
  else {setverdict(fail);}
}

testcase setofCompEnum() runs on setofOper_mycomp{
  var setofOper_mysetof2 x1,x2,x3,x4;	//set of enumerated
  x1:={ xx1,xx2,xx3 };
  x2:={ xx1,xx2,xx3 };
  x3:={ xx1,xx2 };
  x4:={xx3,xx2,xx1};
  if (x1==x2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1==x3)) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4==x2) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
  if (x1!=x3) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1!=x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x4!=x2)) {setverdict(pass);}	// out of order
  else {setverdict(fail);}
}

testcase setofCompRec() runs on setofOper_mycomp{
  var setofOper_mysetof3 x1,x2,x3,x4;	// set of record
  x1 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
  x2 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
  x3 :={ { x1:=2, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
  x4 :={ { x1:=omit, x2:=3.4 }, { x1:=1, x2:=1.2 } };
  if (x1==x2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1==x3)) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4==x2) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
  if (x1!=x3) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1!=x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x4!=x2)) {setverdict(pass);}	// out of order
  else {setverdict(fail);}
}


testcase setofCompRecof() runs on setofOper_mycomp{
  var setofOper_mysetof4 x1,x2,x3,x4; //set of record of
  x1:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
  x2:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
  x3:={ { '12AB'O  }, {'AF12'O} };
  x4:={ {'AF12'O}, { '12AB'O, 'CD12'O } };
  if (x1==x2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1==x3)) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4==x2) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
  if (x2!=x3) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1!=x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x4!=x2)) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
}

testcase setofCompSet() runs on setofOper_mycomp{
  var setofOper_tset temp1:={ x1:=2, x2:=omit };
  var setofOper_mysetof5 x1,x2,x3,x4; //set of set
  x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit } };
  x2:={ { x2:=1.2, x1:=1 }, { x1:=2, x2:=omit }};
  x3:={ { x1:=1, x2:=1.2 } };
  x4:={ { x1:=2, x2:=omit }, { x2:=1.2, x1:=1 } };
  if (x1==x2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x2==x3)) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4==x2) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
  if (x1!=x3) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1!=x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x4!=x2)) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
}

testcase setofCompSetof() runs on setofOper_mycomp{
  var setofOper_tsetof temp2:={"a","7"};
  var setofOper_mysetof6 x1,x2,x3,x4;   //set of set of
  x1:={ { "1", "a" },  temp2 };
  x2:={ { "1", "a" }, {"a","7"} };
  x3:={ { "1", "a" } };
  x4:={ {"a","7"}, { "1", "a" } };
  if (x1==x2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x2==x3)) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4==x2) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
  if (x1!=x3) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1!=x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x4!=x2)) {setverdict(pass);}	// out of order
  else {setverdict(fail);}
}

testcase setofCompUnion() runs on setofOper_mycomp{
  var setofOper_tunion temp5 := {x2:=1.3}
  var setofOper_mysetof7 x1,x2,x3,x4; //set of union
  x1:={ { x1 :=3 }, { x2:=1.3 } };
  x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
  x3:={ { x2 :=3.9 },temp5 }; //{ x2:=1.3 }
  x4:={ { x2:=1.3 }, { x1 :=3 } };
  if (x1==x2) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1==x3)) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4==x2) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
  if (x2!=x3) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x1!=x2)) {setverdict(pass);}
  else {setverdict(fail);}
  if (not(x4!=x2)) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
}

//TR HP50388:
testcase setofCompUnbound() runs on setofOper_mycomp{
  var setofOper_mysetof1 x1,x2,x3,x4;
  x1 := {[3] := 4};
  x2 := {[3] := 4};
  x3 := {-,-,-,4};
  x4 := {-,4,-,-};
  if (x1 == x2) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1 == x3) {setverdict(pass);}
  else {setverdict(fail);}
  if (x1 == x4) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofListOperator() runs on setofOper_mycomp{
  var setofOper_mysetof1 x1:={1,2};
  var setofOper_mysetof1 x2,x3,x4,x5,x6;	//set of basic types
  var setofOper_mysetof1 res1, res2, res3, res4;
  x2:={ 1, 2 };
  x3:={1};
  x4:={1};
  x4[1]:=3;
  x5:={};
  x6[2]:=1;
  res1 := x1 & x2;
  res2 := x1 & x3;
  res3 := x2 & x3 & x5;
  res4 := x3 & x4;
  if (res1 == {1,2,1,2}) {setverdict(pass);}
  else {setverdict(fail);}
  if (res2 == {1,2,1}) {setverdict(pass);}
  else {setverdict(fail);}
  if (res3 == {1,2,1}) {setverdict(pass);}
  else {setverdict(fail);}
  if (res4 == {1,1,3}) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofRotateOperators() runs on setofOper_mycomp{
  var setofOper_mysetof1 x1:={1,2,3,4,5};
  var setofOper_mysetof1 x2,x3,x4,x5,x6,x7;	//set of basic types
  x2 := x1 <@ 1;
  x3 := x1 <@ 10;
  x4 := x1 <@ 3 <@ 2;
  x5 := x1 @> 1;
  x6 := x1 @> 10;
  x7 := x1 @> 3 @> 2;
  if (x2 == x1) {setverdict(pass);}
  else {setverdict(fail);}
  if (x3 == x1) {setverdict(pass);}
  else {setverdict(fail);}
  if (x4 == x1) {setverdict(pass);}
  else {setverdict(fail);}
  if (x5 == x1) {setverdict(pass);}
  else {setverdict(fail);}
  if (x6 == x1) {setverdict(pass);}
  else {setverdict(fail);}
  if (x7 == x1) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofLengthof() runs on setofOper_mycomp{
// lengthof returns the sequential number of the last initialized element of the set of list type
  var setofOper_mysetof1 x1:={1,2};
  var setofOper_mysetof1 x2,x3,x4,x5,x6;	//set of basic types
  x2:={ 1, 2 };
  x3:={1};
  x4:={1};
  x3:={1,2};								//change size by assignment
  x4[1]:=3;									//change size by adding element
  x5:={};									//empty set of
  x6[2]:=1;									//out of order
  if (lengthof(x1)==2) {setverdict(pass);}	//assignment at declaration
  else {setverdict(fail);}
  if (lengthof(x2)==2) {setverdict(pass);}	//assignment later
  else {setverdict(fail);}
  if (lengthof(x3)==2) {setverdict(pass);}	//change size by assignment
  else {setverdict(fail);}
  if (lengthof(x4)==2) {setverdict(pass);}	//change size by adding element
  else {setverdict(fail);}
  if (lengthof(x5)==0) {setverdict(pass);}	//empty set of
  else {setverdict(fail);}
  if (lengthof(x6)==3) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
}

testcase setofSizeof() runs on setofOper_mycomp{
  var setofOper_mysetof1 x1:={1,2};
  var setofOper_mysetof1 x2,x3,x4,x5,x6;	//set of basic types
  x2:={ 1, 2 };
  x3:={1};
  x4:={1};
  x3:={1,2};		//change size by assignment
  x4[1]:=3;		//change size by adding element
  x5:={};			//empty set of
  x6[2]:=1;		//out of order
  if (sizeof(x1)==2) {setverdict(pass);}	//assignment at declaration
  else {setverdict(fail);}
  if (sizeof(x2)==2) {setverdict(pass);}	//assignment later
  else {setverdict(fail);}
  if (sizeof(x3)==2) {setverdict(pass);}	//change size by assignment
  else {setverdict(fail);}
  if (sizeof(x4)==2) {setverdict(pass);}	//change size by adding element
  else {setverdict(fail);}
  if (sizeof(x5)==0) {setverdict(pass);}	//empty set of
  else {setverdict(fail);}
  if (sizeof(x6)==3) {setverdict(pass);}	//out of order
  else {setverdict(fail);}
}

testcase setofReplace() runs on setofOper_mycomp{
  var setofOper_mysetof1 x1:={1,2,3,4,5};
  var setofOper_mysetof1 a:={8,8,8};
  var setofOper_mysetof1 x2;
  x2 := replace(x1,2,3,a);
  if (x2 == {1,2,8,8,8}) {setverdict(pass);}
  else {setverdict(fail);}
}

testcase setofSubstr() runs on setofOper_mycomp{
  var setofOper_mysetof1 x1:={1,2,3,4,5};
  var setofOper_mysetof1 x2;
  x2 := substr(x1,2,3);
  if (x2 == {3,4,5}) {setverdict(pass);}
  else {setverdict(fail);}
}

type record intsetrec { setofOper_mysetof1 a }
type set of intsetrec intsetreclist

testcase setofIsvalue() runs on setofOper_mycomp {
  var setofOper_mysetof1 v_def;
  var setofOper_mysetof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
  var setofOper_mysetof1 v_full := {1,2,3,4,5,6,7,8,9,10}

  if ( isvalue(v_def) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(v_empty) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(v_full) ) { setverdict(pass); } else { setverdict(fail); };

  v_def[1] := 3;

  if ( isvalue(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
  if ( isvalue(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(v_def) ) { setverdict(fail); } else { setverdict(pass); };


  template intsetreclist ist1 := { { a := { 1, 2, 3 } } };
  template intsetreclist ist2 modifies ist1 := { { a := { 1, 2, -, -, -, 100 } } }
  template intsetrec istt1                := { a := { 1, 2, 3 } }
  template intsetrec istt2 modifies istt1 := { a := { 1, 2, -, -, -, 100 } }

  if (isvalue (ist1)) { setverdict ( pass );
  } else { setverdict ( fail ); }
  if (isvalue (ist2)) { setverdict ( fail ); }
  else { setverdict(pass); }
  if (isvalue (istt1)) { setverdict ( pass );}
  else { setverdict ( fail ); }
  if (isvalue (istt2)) { setverdict ( fail ); }
  else { setverdict(pass); }
}

testcase setofIsvalue2() runs on setofOper_mycomp {
  var setofOper_mysetof1 v;
  if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };

  v[3] := 3;
  if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };

  v[2] := 2;
  if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };

  v[1] := 1;
  if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };

  v[0] := 0;
  if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };

  v[4] := 4;
  if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };

  v[6] := 6; // there is now a hole at 5
  if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
}

testcase setofIsbound() runs on setofOper_mycomp {
  var setofOper_mysetof1 v_def;
  var setofOper_mysetof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
  var setofOper_mysetof1 v_full := {1,2,3,4,5,6,7,8,9,10}

  if ( isbound(v_def) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isbound(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isbound(v_empty) ) { setverdict(pass); } else { setverdict(fail); };
  if ( isbound(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isbound(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isbound(v_full) ) { setverdict(pass); } else { setverdict(fail); };

  v_def[1] := 3;

  if ( isbound(v_def) ) { setverdict(pass); } else { setverdict(fail); };
  if ( isbound(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
  if ( isbound(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isbound(v_def[10]) ) { setverdict(fail); } else { setverdict(pass); };


  template intsetreclist ist1 := { { a := { 1, 2, 3 } } };
  template intsetreclist ist2 modifies ist1 := { { a := { 1, 2, -, -, -, 100 } } }
  template intsetrec istt1                := { a := { 1, 2, 3 } }
  template intsetrec istt2 modifies istt1 := { a := { 1, 2, -, -, -, 100 } }

  if (isbound (ist1)) { setverdict(pass); } else { setverdict(fail); };
  if (isbound (ist2)) { setverdict(pass); } else { setverdict(fail); };
  if (isbound (istt1)) { setverdict(pass); } else { setverdict(fail); };
  if (isbound (istt2)) { setverdict(pass); } else { setverdict(fail); };
}

testcase setofCompConst() runs on setofOper_mycomp{
  const setofOper_mysetof1 c_s1 := {1,2,3,4};
  const setofOper_mysetof1 c_s2 := {4,3,2,1};
  const setofOper_mysetof1 c_s3 := {1,3,2,4};
  const setofOper_mysetof1 c_s4 := {1,2,3,4,5};
  const setofOper_mysetof1 c_s5 := {0,1,2,3,4};
  const setofOper_mysetof1 c_s6 := {0,1,2,3,4,5}
  
  const setofOper_mysetof1 c_s1_ind := {[0] := 1,[1] := 2,[2] := 3, [3] := 4};
  const setofOper_mysetof1 c_s2_ind := {[0] := 1,[3] := 4,[2] := 3, [1] := 2};  
  const setofOper_mysetof1 c_s3_ind := {[0] := 2,[3] := 1,[2] := 3, [1] := 4};
  
  var setofOper_mysetof1 vl_s1 := {1,2,3,4};
  
  if(c_s1 == c_s1) {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s1 == {1,2,3,4}) {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s1 == {[0] := 1,[1] := 2,[2] := 3, [3] := 4}) {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s1 == c_s1_ind)  {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s1_ind == c_s2_ind)  {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s1_ind == c_s3_ind)  {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s1 == c_s3_ind)  {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s2_ind == c_s3_ind)  {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s1 == vl_s1) {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s1 == c_s2) {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s1 == c_s3) {setverdict(pass);}
  else {setverdict(fail);}

  if(c_s1 != c_s4) {setverdict(pass);}
  else {setverdict(fail);}

  if(c_s1 != c_s5) {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s1 != c_s6) {setverdict(pass);}
  else {setverdict(fail);}
  
  if(c_s5 != c_s6) {setverdict(pass);}
  else {setverdict(fail);}

}

type set length(5) of set length(6) of charstring StringSetArray length(12)
type set length(4) of charstring MySetof1 length(2)
type set of charstring MySetof2 ("a", "aa", "aaa", "aaaa") length(2)
type set length(2) of charstring MySetof3 ("a", "aa", "aaa", "aaaa")
type set length(2) of charstring MySetof4 ("a", "aa", "aaa", "aaaa") length(2)
// TODO: Add additional subtypes here.
type MySetof2 MySetof5
type MySetof3 MySetof6
type MySetof4 MySetof7
type set of record { charstring id length(2), charstring val length(2) } GenericParameters1
type GenericParameters1[-] GenericParameters2 ({"aa", "aa"})
type GenericParameters1[-] GenericParameters3 ({"aa", "aa"})
// FATAL_ERROR() with R8B: `const GenericParameters1[-] c_pars1 := {c_mysetof6[0], valueof(t_mysetof7[0])}'.
// Possibly the same FATAL_ERROR(): `template MySetof2 t_mysetof8 := {"aa", t_mysetof7[0]} length(2)'.
// `MySetof2' doesn't have a subtype? `type MySetof2 MySetof8 (MySetof2)'
type MySetof3 MySetof8 (MySetof3, MySetof3, MySetof3)

const MySetof2 c_mysetof1 := {}
const MySetof2 c_mysetof2 := {"aa", "aa"}
const MySetof2 c_mysetof3 := {c_mysetof2[0], c_mysetof2[1]}
const MySetof3 c_mysetof4 := {"a", "aa"}
const MySetof3 c_mysetof5 := {c_mysetof4[0], c_mysetof4[1]}
const MySetof4 c_mysetof6 := {"aa", "aa"}
const MySetof4 c_mysetof7 := {c_mysetof6[0], c_mysetof6[1]}

template MySetof2 t_mysetof1 := {}
template MySetof2 t_mysetof2 := {"aa", "aa"}
template MySetof2 t_mysetof3 := c_mysetof2
template MySetof3 t_mysetof4 := {"a", "aa"}
template MySetof3 t_mysetof5 := c_mysetof5
template MySetof4 t_mysetof6 := {"aa", "aa"}
template MySetof4 t_mysetof7 := c_mysetof7
template MySetof2 t_mysetof8 := {"aa", c_mysetof7[0]} length(2)
template MySetof8 t_mysetof9 := {"aa" & "aa", "aa"}

testcase setofSubtypes() runs on setofOper_mycomp {
  var template MySetof1 vt_mysetof1 := {"AA", "AB", "BA", "BB"}
  var MySetof1 v_mysetof1 := {"AA", "AB", "BA", "BB"}
  // TITAN compiles this.
  if (substr(v_mysetof1, 0, 2) == {"AA", "AB"} and {"BA", "BB"} == substr(valueof(vt_mysetof1), 2, 2)) { setverdict(pass) }
  else { setverdict(fail) }
}

control {
  const setofOper_trecord cl_temp1:={ x1:=omit, x2:=3.4 }; //constant in control part
  const setofOper_trecof cl_temp2:={ 'AF12'O };
  const setofOper_tset cl_temp3:={ x1:=234, x2:=1.9};
  const setofOper_tsetof cl_temp4:={"f","8"};
  const setofOper_tunion cl_temp5:={ x2:=1.3 };
  var setofOper_trecord vl_temp1; //variable in control part
  var setofOper_trecof vl_temp2;
  var setofOper_tset vl_temp3;
  var setofOper_tsetof vl_temp4;
  var setofOper_tunion vl_temp5;

  execute(setofAssign());
  execute(setofAssignEnum());
  execute(setofAssignRec());
  execute(setofAssignRecof());
  execute(setofAssignSet());
  execute(setofAssignSetof());
  execute(setofAssignUnion());
  execute(setofAssignElem());
  execute(setofAssignElemEnum());
  execute(setofAssignElemRec());
  execute(setofAssignElemRecof());
  execute(setofAssignElemSet());
  execute(setofAssignElemSetof());
  execute(setofAssignElemUnion());
  execute(setofConst());
  execute(setofConstEnum());
  execute(setofConstRec());
  execute(setofConstRecof());
  execute(setofConstSet());
  execute(setofConstSetof());
  execute(setofConstUnion());
  execute(setofConstComp());
  execute(setofComp());
  execute(setofCompConst());
  execute(setofCompEnum());
  execute(setofCompRec());
  execute(setofCompRecof());
  execute(setofCompSet());
  execute(setofCompSetof());
  execute(setofCompUnion());  
  execute(setofCompUnbound());
  execute(setofListOperator());
  execute(setofRotateOperators());
  execute(setofLengthof());
  execute(setofSizeof());
  execute(setofReplace());
  execute(setofSubstr());
  execute(setofIsvalue());
  execute(setofIsvalue2());
  execute(setofIsbound());


  execute(setofSubtypes());
  
  
}

}