Sync with 5.4.0

[deliverable/titan.core.git] / regression_test / setOper / TsetOper.ttcn

/******************************************************************************
 * Copyright (c) 2000-2015 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
 ******************************************************************************/
module TsetOper {
// ********** Type definitions  *********************
type component setOper_mycomp {};
type set typedefset_empty {};
type enumerated setOper_myenum {xx1,xx2,xx3};
type record setOper_trecord {
	integer x1 optional,
	float x2 };
type record of octetstring setOper_trecof;
type set setOper_tset {
	integer x1,
	float x2 optional };
type set of charstring setOper_tsetof;
type union setOper_tunion {
	integer x1,
	float x2 };
type set setOper_myset1 {	// set from basic types
	integer x1,
	float x2,
	setOper_myenum x3 };
type set setOper_myset2 {	// set from basic types, with optional field
	integer x1,
	float x2,
	setOper_myenum x3,
	integer x4 optional };
type set setOper_myset3 {	 // set from record, with optional field
	setOper_trecord x1,
	setOper_trecord x2 optional
	};
type set setOper_myset4 {	 // set from record of, with optional field
	setOper_trecof x1,
	setOper_trecof x2 optional
	};
type set setOper_myset5 {	 // set from set, with optional field
	setOper_tset x1,
	setOper_tset x2 optional
	};
type set setOper_myset6 {	 // set from set of, with optional field
	setOper_tsetof x1,
	setOper_tsetof x2 optional
	};
type set setOper_myset7 {	 // set from union, with optional field
	setOper_tunion x1,
	setOper_tunion x2 optional
	};
type set typedefsetComp_myset {
	setOper_trecord x1,
	setOper_trecof x2,
	setOper_tset x3,
	setOper_tsetof x4 optional,
	setOper_tunion x5,
	integer x6[3]
	};
// *************** Constanst ***********************
const setOper_trecord setOper_temp1:={ x1:=omit, x2:=3.4 };
const setOper_trecof setOper_temp2:={ 'AF12'O };
const setOper_tset setOper_temp3:={ x1:=234, x2:=1.9};
const setOper_tsetof setOper_temp4:={"f","8"};
const setOper_tunion setOper_temp5:={ x2:=1.3 };
const setOper_myset1 setOper_const1:={	//set with basic types
x1:=1,
x2:=1.2,
x3:=xx2 };
const setOper_myset2 setOper_const2:={	//set with basic types, with optional field
x1:=1,
x2:=1.2,
x3:=xx2,
x4:=2 };
const setOper_myset2 setOper_const3:={	//set with basic types, with omited field
x1:=1,
x2:=1.2,
x3:=xx2,
x4:=omit };
const setOper_myset3 setOper_const4:={   //set from record
 x1:={ x1:=1, x2:=1.2 },
 x2:=setOper_temp1
};
const setOper_myset3 setOper_const5:={   //set from record, with omited field
 x1:={ x1:=1, x2:=1.2 },
 x2:=omit
};
const setOper_myset4 setOper_const6:={   //set from record of
 x1:={ '12AB'O, 'CD12'O },
 x2:=setOper_temp2
};
const setOper_myset4 setOper_const7:={   //set from record of, with omited field
 x1:={ '12AB'O, 'CD12'O },
 x2:=omit
};
const setOper_myset5 setOper_const8:={   //set from set
 x1:={ x1:=2, x2:=1.3},
 x2:=setOper_temp3
};
const setOper_myset5 setOper_const9:={   //set from set, with omited field
 x1:={ x1:=2, x2:=1.3},
 x2:=omit
};
const setOper_myset6 setOper_const10:={   //set from set of
 x1:={"a","b"},
 x2:=setOper_temp4  //{"f","8"},
};
const setOper_myset6 setOper_const11:={   //set from set of, with omited field
 x1:={"a","b"},
 x2:=omit
};
const setOper_myset7 setOper_const12:={   //set from union
 x1:={ x1 :=3 },
 x2:=setOper_temp5  //{ x2:=1.3 }
};
const setOper_myset7 setOper_const13:={   //set from union, with omited field
 x1:={ x1 :=3 },
 x2:=omit
};
const typedefsetComp_myset setOper_const14 := { // complex set
  x1 := { x1:=omit, x2:=3.4 },
  x2 := { 'AF12'O },
  x3 := { x1:=234, x2:=1.9},
  x4 := {"f","8"},
  x5 := { x2:=1.3 },
  x6 := {1,2,3}
}

testcase setAssign() runs on setOper_mycomp{
var setOper_myset1 x1:={	//set with basic types
x1:=1,
x2:=1.2,
x3:=xx2 };
var setOper_myset1 x2,x3;
x2:={ x1:=1, x2:=1.2, x3:=xx2 };
x3:={ x2:=1.2, x1:=1,  x3:=xx2 };
if (x1.x1==1) {setverdict(pass);}	//at declaration
     else {setverdict(fail);}
if (x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x1==1) {setverdict(pass);}	//later
     else {setverdict(fail);}
if (x2.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x1==1) {setverdict(pass);}	//out of order
     else {setverdict(fail);}
if (x3.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignOpt() runs on setOper_mycomp{
var integer inttemp:=2;
var setOper_myset2 x1:={	//set with basic types, with optional field
  x1:=1,
  x2:=1.2,
  x3:=xx2,
  x4:=inttemp};  //2
var setOper_myset2 x2:={	//set with basic types, with omited field
  x1:=1,
  x2:=1.2,
  x3:=xx2,
  x4:=omit };
var setOper_myset2 x3, x4;
x3:={	//set with basic types, with optional field
  x1:=1,
  x2:=1.2,
  x3:=xx2,
  x4:=inttemp };   //2
x4:={	//set with basic types, with omited field
  x1:=1,
  x2:=1.2,
  x3:=xx2,
  x4:=omit };
//at declaration, with optional field
if (x1.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x4==2) {setverdict(pass);}
     else {setverdict(fail);}
//at declaration, with omited field
if (x2.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x2.x4))) {setverdict(pass);}
     else {setverdict(fail);}
//later, with optional field
if (x3.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x4==2) {setverdict(pass);}
     else {setverdict(fail);}
//later, with optional field
if (x4.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (x4.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x4.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x4.x4))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignRec() runs on setOper_mycomp{
var setOper_trecord temp1:={ x1:=omit, x2:=3.4 };
var setOper_myset3 x1:={   //set from record
 x1:={ x1:=1, x2:=1.2 },
 x2:=temp1
};
var setOper_myset3 x2:={   //set from record, with omited field
 x1:={ x1:=1, x2:=1.2 },
 x2:=omit
};
var setOper_myset3 x3,x4;
x3:={   //set from record
 x1:={ x1:=1, x2:=1.2 },
 x2:=temp1
};
x4:={   //set from record, with omited field
 x1:={ x1:=1, x2:=1.2 },
 x2:=omit
};
if (x1.x1.x1==1) {setverdict(pass);}	//at declaration
     else {setverdict(fail);}
if (x1.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==temp1) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x1.x1==1) {setverdict(pass);}	//at declaration, omit
     else {setverdict(fail);}
if (x2.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x2.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x1.x1==1) {setverdict(pass);}	//later
     else {setverdict(fail);}
if (x3.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x2==temp1) {setverdict(pass);}
     else {setverdict(fail);}
if (x4.x1.x1==1) {setverdict(pass);}	//later, omit
     else {setverdict(fail);}
if (x4.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x4.x2))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignRecof() runs on setOper_mycomp{
var setOper_trecof temp2:={'AF12'O};
var setOper_myset4 x1:={   //set from record of
 x1:={ '12AB'O, 'CD12'O },
 x2:=temp2
};
var setOper_myset4 x2:={   //set from record of, with omited field
 x1:={ '12AB'O, 'CD12'O },
 x2:=omit
};
var setOper_myset4 x3,x4
x3:={   //set from record of
 x1:={ '12AB'O, 'CD12'O },
 x2:=temp2
};
x4:={   //set from record of, with omited field
 x1:={ '12AB'O, 'CD12'O },
 x2:=omit
};
if (x1.x1[0]=='12AB'O) {setverdict(pass);}	//at declaration
     else {setverdict(fail);}
if (x1.x1[1]=='CD12'O) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==temp2) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x1[0]=='12AB'O) {setverdict(pass);}	//at declaration, omit
     else {setverdict(fail);}
if (x2.x1[1]=='CD12'O) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x2.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x1[0]=='12AB'O) {setverdict(pass);}	//later
     else {setverdict(fail);}
if (x3.x1[1]=='CD12'O) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x2==temp2) {setverdict(pass);}
     else {setverdict(fail);}
if (x4.x1[0]=='12AB'O) {setverdict(pass);}	//later, omit
     else {setverdict(fail);}
if (x4.x1[1]=='CD12'O) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x4.x2))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignSet() runs on setOper_mycomp{
var setOper_tset temp1:={ x1:=2, x2:=omit };
var setOper_myset5 x1:={   //set from set
 x1:={ x1:=1, x2:=1.2 },
 x2:=temp1
};
var setOper_myset5 x2:={   //set from set, with omited field
 x1:={ x1:=1, x2:=1.2 },
 x2:=omit
};
var setOper_myset5 x3,x4;
x3:={   //set from set
 x1:={ x1:=1, x2:=1.2 },
 x2:=temp1
};
x4:={   //set from set, with omited field
 x1:={ x1:=1, x2:=1.2 },
 x2:=omit
};
if (x1.x1.x1==1) {setverdict(pass);}	//at declaration
     else {setverdict(fail);}
if (x1.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==temp1) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x1.x1==1) {setverdict(pass);}	//at declaration, omit
     else {setverdict(fail);}
if (x2.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x2.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x1.x1==1) {setverdict(pass);}	//later
     else {setverdict(fail);}
if (x3.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x2==temp1) {setverdict(pass);}
     else {setverdict(fail);}
if (x4.x1.x1==1) {setverdict(pass);}	//later, omit
     else {setverdict(fail);}
if (x4.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x4.x2))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignSetof() runs on setOper_mycomp{
var setOper_tsetof temp2:={"a","7"};
var setOper_myset6 x1:={   //set from set of
 x1:={ "1", "a" },
 x2:=temp2
};
var setOper_myset6 x2:={   //set from set of, with omited field
 x1:={ "1", "a" },
 x2:=omit
};
var setOper_myset6 x3,x4
x3:={   			//set from set of
 x1:={ "1", "a" },
 x2:=temp2
};
x4:={   		//set from set of, with omited field
 x1:={ "1","a" },
 x2:=omit
};
if (x1.x1[0]=="1") {setverdict(pass);}	//at declaration
     else {setverdict(fail);}
if (x1.x1[1]=="a") {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==temp2) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x1[0]=="1") {setverdict(pass);}	//at declaration, omit
     else {setverdict(fail);}
if (x2.x1[1]=="a") {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x2.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x1[0]=="1") {setverdict(pass);}	//later
     else {setverdict(fail);}
if (x3.x1[1]=="a") {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x2==temp2) {setverdict(pass);}
     else {setverdict(fail);}
if (x4.x1[0]=="1") {setverdict(pass);}	//later, omit
     else {setverdict(fail);}
if (x4.x1[1]=="a") {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x4.x2))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignUnion() runs on setOper_mycomp{
var setOper_tunion temp5 := {x2:=1.3}
var setOper_myset7 x1:={   //set from union
 x1:={ x1 :=3 },
 x2:=temp5  //{ x2:=1.3 }
};
var setOper_myset7 x2:={   //set from union, with omited field
 x1:={ x1 :=3 },
 x2:=omit
};
var setOper_myset7 x3,x4;
x3:={   //set from union
 x1:={ x1 :=3 },
 x2:=temp5  //{ x2:=1.3 }
};
x4:={   //set from union, with omited field
 x1:={ x1 :=3 },
 x2:=omit
};
if (x1.x1.x1==3) {setverdict(pass);}	//at declaration
     else {setverdict(fail);}
if (ischosen(x1.x1.x1)) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ischosen(x1.x1.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==temp5) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x1.x1==3) {setverdict(pass);}	//at declaration, omit
     else {setverdict(fail);}
if (ischosen(x2.x1.x1)) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ischosen(x2.x1.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x2.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x1.x1==3) {setverdict(pass);}	//later
     else {setverdict(fail);}
if (ischosen(x3.x1.x1)) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ischosen(x3.x1.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x2==temp5) {setverdict(pass);}
     else {setverdict(fail);}
if (x4.x1.x1==3) {setverdict(pass);}	//later, omit
     else {setverdict(fail);}
if (ischosen(x4.x1.x1)) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ischosen(x4.x1.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x4.x2))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignElem() runs on setOper_mycomp{
var setOper_myset1 x1:={	//set with basic types
x1:=1,
x2:=1.2,
x3:=xx2 };
x1.x2:=3.4;
if (x1.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==3.4) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
}


testcase setAssignElemOpt() runs on setOper_mycomp{
var integer inttemp:=2;
var setOper_myset2 x1:={	//set with basic types
x1:=1,
x2:=1.2,
x3:=xx2,
x4:=omit } ;  //2
var setOper_myset2 x2, x3, x4;
x2:=x1;
x3:={x1:=1, x2:=1.2, x3:=xx2, x4:=inttemp };
x4:=x3;
x1.x1:=2;			//not optional field
x2.x4:=3;			//optional field; omited-> value
x3.x4:=3;			//optional field; value-> value
x4.x4:=omit;			//optional field; value -> omited
//not optional field
if (x1.x1==2) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x1.x4))) {setverdict(pass);}
     else {setverdict(fail);}
//optional field, omited -> value
if (x2.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (x2.x4==3) {setverdict(pass);}
     else {setverdict(fail);}
//optional field; value-> value
if (x3.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (x3.x4==3) {setverdict(pass);}
     else {setverdict(fail);}
//optional field; value -> omited
if (x4.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (x4.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x4.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(x4.x4))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignElemRec() runs on setOper_mycomp{
var setOper_trecord temp1:={ x1:=omit, x2:=3.4 };
var setOper_myset3 x1;
x1:={   //set from record
 x1:={ x1:=1, x2:=1.2 },
 x2:=temp1
};
x1.x1.x1:=2;
temp1.x1:=3;
x1.x2:=temp1;
if (x1.x1.x1==2) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==temp1) {setverdict(pass);}
     else {setverdict(fail);}
}


testcase setAssignElemRecof() runs on setOper_mycomp{
var setOper_trecof temp2:={'AF12'O};
var setOper_myset4 x1:={   //set from record of
 x1:={ '12AB'O, 'CD12'O },
 x2:=temp2
};
x1.x1[1]:='34AB'O;
if (x1.x1[0]=='12AB'O) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x1[1]=='34AB'O) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==temp2) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignElemSet() runs on setOper_mycomp{
var setOper_tset temp1:={ x1:=2, x2:=omit };
var setOper_myset5 x1:={   //set from set
 x1:={ x1:=1, x2:=1.2 },
 x2:=temp1
};
x1.x1.x2:=3.4;
if (x1.x1.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x1.x2==3.4) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==temp1) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignElemSetof() runs on setOper_mycomp{
var setOper_tsetof temp2:={"a","7"};
var setOper_myset6 x1:={   //set from set of
 x1:={ "1", "a" },
 x2:=temp2
};
x1.x1[0]:="h";
if (x1.x1[0]=="h") {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x1[1]=="a") {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==temp2) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setAssignElemUnion() runs on setOper_mycomp{
var setOper_tunion temp5 := {x2:=1.3}
var setOper_myset7 x1:={   //set from union
 x1:={ x1 :=3 },
 x2:=temp5  //{ x2:=1.3 }
};
x1.x1.x2:=3.4;
if (x1.x1.x2==3.4) {setverdict(pass);}
     else {setverdict(fail);}
if (ischosen(x1.x1.x2)) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ischosen(x1.x1.x1))) {setverdict(pass);}
     else {setverdict(fail);}
if (x1.x2==temp5) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setSizeof() runs on setOper_mycomp{
var integer inttemp:=2;
var setOper_myset2 x1:={	//set with basic types, with optional field
x1:=1,
x2:=1.2,
x3:=xx2,
x4:=inttemp};  //2
var setOper_myset2 x2:={	//set with basic types, with omited field
x1:=1,
x2:=1.2,
x3:=xx2,
x4:=omit };
var setOper_myset2 x3, x4;
x3:={				//set with basic types, with optional field
x1:=1,
x2:=1.2,
x3:=xx2,
x4:=inttemp };   //2
x4:={				//set with basic types, with omited field
x1:=1,
x2:=1.2,
x3:=xx2,
x4:=omit };
//if (sizeof(x1)==4) {setverdict(pass);} //at declaration, with optional field
//     else {setverdict(fail);}
//if (sizeof(x2)==3) {setverdict(pass);}	//at declaration, with omited field
//     else {setverdict(fail);}
//if (sizeof(x3)==4) {setverdict(pass);}	//later, with optional field
//     else {setverdict(fail);}
//if (sizeof(x4)==3) {setverdict(pass);}	//testcase, with optional field
//     else {setverdict(fail);}
//if (sizeof(setOper_myset2)==4) {setverdict(pass);}	// size of type
//     else {setverdict(fail);}
}

testcase setConst() runs on setOper_mycomp{
const setOper_myset1 const1:={	//set with basic types
x1:=1,
x2:=1.2,
x3:=xx2 };
if (setOper_const1.x1==1) {setverdict(pass);}	//definition part
     else {setverdict(fail);}
if (setOper_const1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const1.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (const1.x1==1) {setverdict(pass);}	//testcase
     else {setverdict(fail);}
if (const1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (const1.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setConstOpt() runs on setOper_mycomp{
const setOper_myset2 const2:={	//set with basic types, with optional field
x1:=1,
x2:=1.2,
x3:=xx2,
x4:=2 };
const setOper_myset2 const3:={	//set with basic types, with omited field
x1:=1,
x2:=1.2,
x3:=xx2,
x4:=omit };
//definition part, with optional field
if (setOper_const2.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const2.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const2.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const2.x4==2) {setverdict(pass);}
     else {setverdict(fail);}
//definition part, with omited field
if (setOper_const3.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const3.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const3.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(setOper_const3.x4))) {setverdict(pass);}
     else {setverdict(fail);}
//testcase, with optional field
if (const2.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (const2.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (const2.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (const2.x4==2) {setverdict(pass);}
     else {setverdict(fail);}
//testcase, with optional field
if (const3.x1==1) {setverdict(pass);}
     else {setverdict(fail);}
if (const3.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (const3.x3==xx2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(const3.x4))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setConstRec() runs on setOper_mycomp{
const setOper_myset3 const4:={   //set from record
 x1:={ x1:=1, x2:=1.2 },
 x2:=setOper_temp1
};
const setOper_myset3 const5:={   //set from record, with omited field
 x1:={ x1:=1, x2:=1.2 },
 x2:=omit
};
if (setOper_const4.x1.x1==1) {setverdict(pass);}	//definition part
     else {setverdict(fail);}
if (setOper_const4.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const4.x2==setOper_temp1) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const5.x1.x1==1) {setverdict(pass);}	//definition part, omit
     else {setverdict(fail);}
if (setOper_const5.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(setOper_const5.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (const4.x1.x1==1) {setverdict(pass);}	//testcase
     else {setverdict(fail);}
if (const4.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (const4.x2==setOper_temp1) {setverdict(pass);}
     else {setverdict(fail);}
if (const5.x1.x1==1) {setverdict(pass);}	//testcase part, omit
     else {setverdict(fail);}
if (const5.x1.x2==1.2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(const5.x2))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setConstRecof() runs on setOper_mycomp{
const setOper_myset4 const6:={   //set from record of
 x1:={ '12AB'O, 'CD12'O },
 x2:=setOper_temp2
};
const setOper_myset4 const7:={   //set from record of, with omited field
 x1:={ '12AB'O, 'CD12'O },
 x2:=omit
};
if (setOper_const6.x1[0]=='12AB'O) {setverdict(pass);}	//definition part
     else {setverdict(fail);}
if (setOper_const6.x1[1]=='CD12'O) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const6.x2==setOper_temp2) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const7.x1[0]=='12AB'O) {setverdict(pass);}	//definition part, omit
     else {setverdict(fail);}
if (setOper_const7.x1[1]=='CD12'O) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(setOper_const7.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (const6.x1[0]=='12AB'O) {setverdict(pass);}	//testcase
     else {setverdict(fail);}
if (const6.x1[1]=='CD12'O) {setverdict(pass);}
     else {setverdict(fail);}
if (const6.x2==setOper_temp2) {setverdict(pass);}
     else {setverdict(fail);}
if (const7.x1[0]=='12AB'O) {setverdict(pass);}	//testcase part, omit
     else {setverdict(fail);}
if (const7.x1[1]=='CD12'O) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(const7.x2))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setConstSet() runs on setOper_mycomp{
const setOper_myset5 const8:={   //set from set
 x1:={ x1:=2, x2:=1.3},
 x2:=setOper_temp3
};
const setOper_myset5 const9:={   //set from set, with omited field
 x1:={ x1:=2, x2:=omit},
 x2:=omit
};
if (setOper_const8.x1.x1==2) {setverdict(pass);}	//definition part
     else {setverdict(fail);}
if (setOper_const8.x1.x2==1.3) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const8.x2==setOper_temp3) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const9.x1.x1==2) {setverdict(pass);}	//definition part, omit
     else {setverdict(fail);}
if (setOper_const9.x1.x2==1.3) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(setOper_const9.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (const8.x1.x1==2) {setverdict(pass);}	//testcase
     else {setverdict(fail);}
if (const8.x1.x2==1.3) {setverdict(pass);}
     else {setverdict(fail);}
if (const8.x2==setOper_temp3) {setverdict(pass);}
     else {setverdict(fail);}
if (const9.x1.x1==2) {setverdict(pass);}	//testcase part, omit
     else {setverdict(fail);}
if (not(ispresent(const9.x1.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(const9.x2))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setConstSetof() runs on setOper_mycomp{
const setOper_myset6 const10:={   //set from set of
 x1:={"a","b"},
 x2:=setOper_temp4  //{"f","8"},
};
const setOper_myset6 const11:={   //set from set of, with omited field
 x1:={"a","b"},
 x2:=omit
};
if (setOper_const10.x1[0]=="a") {setverdict(pass);}	//definition part
     else {setverdict(fail);}
if (setOper_const10.x1[1]=="b") {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const10.x2==setOper_temp4) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const11.x1[0]=="a") {setverdict(pass);}	//definition part, omit
     else {setverdict(fail);}
if (setOper_const11.x1[1]=="b") {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(setOper_const11.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (const10.x1[0]=="a") {setverdict(pass);}	//testcase
     else {setverdict(fail);}
if (const10.x1[1]=="b") {setverdict(pass);}
     else {setverdict(fail);}
if (const10.x2==setOper_temp4) {setverdict(pass);}
     else {setverdict(fail);}
if (const11.x1[0]=="a") {setverdict(pass);}	//testcase part, omit
     else {setverdict(fail);}
if (const11.x1[1]=="b") {setverdict(pass);}
     else {setverdict(fail);}
if (not(ispresent(const11.x2))) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setConstUnion() runs on setOper_mycomp{
const setOper_myset7 const12:={   //set from union
 x1:={ x1 :=3 },
 x2:=setOper_temp5  //{ x2:=1.3 }
};
const setOper_myset7 const13:={   //set from union, with omited field
 x1:={ x1 :=3 },
 x2:=omit
};
if (setOper_const12.x1.x1==3) {setverdict(pass);}	//definition part
     else {setverdict(fail);}
if (setOper_const12.x2==setOper_temp5) {setverdict(pass);}
     else {setverdict(fail);}
if (setOper_const13.x1.x1==3) {setverdict(pass);}	//definition part, omit
     else {setverdict(fail);}
if (not(ispresent(setOper_const13.x2))) {setverdict(pass);}
     else {setverdict(fail);}
if (const12.x1.x1==3) {setverdict(pass);}	//testcase
     else {setverdict(fail);}
if (const12.x2==setOper_temp5) {setverdict(pass);}
     else {setverdict(fail);}
if (const13.x1.x1==3) {setverdict(pass);}	//testcase part, omit
     else {setverdict(fail);}
if (not(ispresent(const13.x2))) {setverdict(pass);}
     else {setverdict(fail);}
}


testcase setComp() runs on setOper_mycomp{
var setOper_myset1 x1,x2,x3,x4;
x1:={ x1:=1, x2:=1.2, x3:=xx2 };
x2:={ x1:=1, x2:=1.2, x3:=xx2 };
x3:={ x1:=1, x2:=1.24, x3:=xx2 };
x4:={ x2:=1.2, x1:=1, x3:=xx2 };
if (x1==x2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1==x3)) {setverdict(pass);}
     else {setverdict(fail);}
if (x1!=x3) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1!=x2)) {setverdict(pass);}
     else {setverdict(fail);}
if (x4==x2) {setverdict(pass);}	//out of order
     else {setverdict(fail);}
if (not(x4==x3)) {setverdict(pass);}
     else {setverdict(fail);}
if (x4!=x3) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x4!=x2)) {setverdict(pass);}
     else {setverdict(fail);}
}


testcase setCompOpt() runs on setOper_mycomp{
var integer inttemp:=2;	// set with basic types with optional field
var setOper_myset2 x1,x2,x3;
x1 :={	x1:=1, x2:=1.2, x3:=xx2, x4:=inttemp };  //inntemp=2
x2:= { x1:=1, x2:=1.2, x3:=xx2, x4:=omit };
x3:= { x1:=1, x2:=1.2, x3:=xx2, x4:=omit };
if (x2==x3) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1==x2)) {setverdict(pass);}
     else {setverdict(fail);}
if (x1!=x3) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x2!=x3)) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setCompRec() runs on setOper_mycomp{
var setOper_trecord temp1:={ x1:=omit, x2:=3.4 }; // set with record
var setOper_myset3 x1,x2,x3;
x1 :={
 x1:={ x1:=1, x2:=1.2 },
 x2:=temp1
};
x2 :={
 x1:={ x1:=1, x2:=1.2 },
 x2:=temp1
};
x3 :={
 x1:={ x1:=2, x2:=1.2 },
 x2:=temp1
};
if (x1==x2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1==x3)) {setverdict(pass);}
     else {setverdict(fail);}
if (x1!=x3) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1!=x2)) {setverdict(pass);}
     else {setverdict(fail);}
}


testcase setCompRecof() runs on setOper_mycomp{
var setOper_trecof temp2:={'AF12'O};
var setOper_myset4 x1,x2,x3;
x1:={   				//set from record of
 x1:={ '12AB'O, 'CD12'O },
 x2:=temp2
};
x2:={
 x1:={ '12AB'O, 'CD12'O },
 x2:=temp2
};
x3:={
 x1:={ '12AB'O },
 x2:=temp2
};
if (x1==x2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1==x3)) {setverdict(pass);}
     else {setverdict(fail);}
if (x2!=x3) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1!=x2)) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setCompSet() runs on setOper_mycomp{
var setOper_tset temp1:={ x1:=2, x2:=omit };
var setOper_myset5 x1,x2,x3
x1:={   				//set from set
 x1:={ x1:=1, x2:=1.2 },
 x2:=temp1
};
x2:={
 x1:={ x1:=1, x2:=1.2 },
 x2:=temp1
};
x3:={
 x1:={ x1:=4, x2:=1.2 },
 x2:=temp1
};
if (x1==x2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x2==x3)) {setverdict(pass);}
     else {setverdict(fail);}
if (x1!=x3) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1!=x2)) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setCompSetof() runs on setOper_mycomp{
var setOper_tsetof temp2:={"a","7"};
var setOper_myset6 x1,x2,x3;
x1:={   				//set from set of
 x1:={ "1", "a" },
 x2:=temp2
};
x2:={
 x1:={ "1", "a" },
 x2:=temp2
};
x3:={
 x1:={ "1", "a", "k" },
 x2:=temp2
};
if (x1==x2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x2==x3)) {setverdict(pass);}
     else {setverdict(fail);}
if (x1!=x3) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1!=x2)) {setverdict(pass);}
     else {setverdict(fail);}
}

testcase setCompUnion() runs on setOper_mycomp{
var setOper_tunion temp5 := {x2:=1.3}
var setOper_myset7 x1,x2,x3;
x1:={   				//set from union
 x1:={ x1 :=3 },
 x2:=temp5  //{ x2:=1.3 }
};
x2:={
 x1:={ x1 :=3 },
 x2:=temp5  //{ x2:=1.3 }
};
x3:={
 x1:={ x2 :=3.9 },
 x2:=temp5  //{ x2:=1.3 }
};
if (x1==x2) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1==x3)) {setverdict(pass);}
     else {setverdict(fail);}
if (x2!=x3) {setverdict(pass);}
     else {setverdict(fail);}
if (not(x1!=x2)) {setverdict(pass);}
     else {setverdict(fail);}
}

type set myset1 {
  integer f1 (0..255),
  charstring f2 length(0..255)
}
type myset1 myset2 ({f1 := 0, f2 := ""})
type myset1 myset3
type myset1 myset4 ({f1 := c_mysetlen1, f2 := "hello"}, {f1 := c_mysetlen2, f2 := "world"})

const integer c_mysetlen1 := 255
const integer c_mysetlen2 := c_mysetlen1
const myset4 c_myset1 := {f1 := 255, f2 := "world"}

template myset4 t_myset1 := {f1 := 255, f2 := "hello"}
// The following line shouldn't work.  Delete it later.
template myset4 t_myset2 modifies t_myset1 := {f1 := 1, f2 := ""}

function f_set1() return myset2 { return {f1 := 0, f2 := ""} }

function f_set2() return boolean {
  var integer v_i1 := 100
  var charstring v_s1 := "abc"
  var myset4 v_myset1 := valueof(t_myset1)
  // It doesn't work yet: `var myset4 v_myset2 := {f1 := v_i1, f2 := v_s1}'.  Replace
  // the test later.
  var myset4 v_myset2 := valueof(modifies t_myset1 := {f2 := ""})
  var myset4 v_myarr1[3] := {c_myset1, {f1 := 255, f2 := "he" & "llo"}, valueof(t_myset1)}
  if (v_myset1 != v_myarr1[2]) { return false }
  else {
    log(v_myset1)
    log(v_myarr1)
    if (v_myset1.f1 == v_myarr1[0].f1 and v_myset2.f1 == v_myarr1[1].f1 and 255 == v_myarr1[2].f1 and
        v_myset1.f2 != v_myarr1[0].f2 and v_myset2.f2 != v_myarr1[1].f2 and "hello" == v_myarr1[2].f2) {
      return true
    }
    return false
  }
}

testcase setSubtypes() runs on setOper_mycomp {
  var template myset1 vt_myset1 := { f1 := 0, f2 := "" }
  var myset1 v_myset1 := { f1 := valueof(vt_myset1.f1), f2 := valueof(vt_myset1.f2) }

  if (f_set1() == v_myset1 and valueof(vt_myset1) == f_set1()) { setverdict(pass) }
  else { setverdict(fail) }
  if (f_set2()) { setverdict(pass) }
  else { setverdict(fail) }
}

testcase setIsvalue() runs on setOper_mycomp{
  var typedefset_empty v1;
  var setOper_trecord vs2_def;
  var setOper_trecord v2;
  v2.x1 := 42;

  if ( isvalue(v1) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(vs2_def) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(v2) ) { setverdict(fail); } else { setverdict(pass); };

  var setOper_trecord vs2_part := { -, 1.0 };
  if ( isvalue(vs2_part) ) { setverdict(fail); } else { setverdict(pass); };
  vs2_part.x1 := omit;
  if ( isvalue(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };

  var setOper_trecord vs2_om := { omit, - };
  if ( isvalue(vs2_om) ) { setverdict(fail); } else { setverdict(pass); };
  vs2_om.x2 := 33.0;
  if ( isvalue(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
}

testcase setIsbound() runs on setOper_mycomp{
  var typedefset_empty v1;
  var setOper_trecord vs2_def;
  var setOper_trecord v2;
  v2.x1 := 42;

  if ( isbound(v1) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isbound(vs2_def) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isbound(vs2_def.x1) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isbound(vs2_def.x2) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isbound(v2) ) { setverdict(pass); } else { setverdict(fail); };

  var setOper_trecord vs2_part := { -, 1.0 };
  if ( isbound(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };
  vs2_part.x1 := omit;
  if ( isbound(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };

  var setOper_trecord vs2_om := { omit, - };
  if ( isbound(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
  vs2_om.x2 := 33.0;
  if ( isbound(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
}

control {
 const setOper_trecord cl_temp1:={ x1:=omit, x2:=3.4 }; //constant in control part
 const setOper_trecof cl_temp2:={ 'AF12'O };
 const setOper_tset cl_temp3:={ x1:=234, x2:=1.9};
 const setOper_tsetof cl_temp4:={"f","8"};
 const setOper_tunion cl_temp5:={ x2:=1.3 };
 const typedefsetComp_myset cl_const14 := {
  x1 := { x1:=omit, x2:=3.4 },
  x2 := { 'AF12'O },
  x3 := { x1:=234, x2:=1.9},
  x4 := {"f","8"},
  x5 := { x2:=1.3 },
  x6 := {1,2,3}
 }
 var setOper_trecord vl_temp1; //variable in control part
 var setOper_trecof vl_temp2;
 var setOper_tset vl_temp3;
 var setOper_tsetof vl_temp4;
 var setOper_tunion vl_temp5;
 var typedefsetComp_myset vl_const14;

 execute(setAssign());
 execute(setAssignOpt());
 execute(setAssignRec());
 execute(setAssignRecof());
 execute(setAssignSet());
 execute(setAssignSetof());
 execute(setAssignUnion());
 execute(setAssignElem());
 execute(setAssignElemOpt());
 execute(setAssignElemRec());
 execute(setAssignElemRecof());
 execute(setAssignElemSet());
 execute(setAssignElemSetof());
 execute(setAssignElemUnion());
// execute(setSizeof());
 execute(setConst());
 execute(setConstOpt());
 execute(setConstRec());
 execute(setConstRecof());
 execute(setConstSet());
 execute(setConstSetof());
 execute(setConstUnion());
 execute(setComp());
 execute(setCompOpt());
 execute(setCompRec());
 execute(setCompRecof());
 execute(setCompSet());
 execute(setCompSetof());
 execute(setCompUnion());
 execute(setSubtypes());
 execute(setIsvalue());
 execute(setIsbound());
}
}