regression_test/setofOper/TsetofOper.ttcn

   1 /******************************************************************************
   2  * Copyright (c) 2000-2014 Ericsson Telecom AB
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  ******************************************************************************/
   8 module TsetofOper {
   9 // ********** Type definitions  *********************
  10 type component setofOper_mycomp {};
  11 type enumerated setofOper_myenum {xx1,xx2,xx3};
  12 type record setofOper_trecord {
  13   integer x1 optional,
  14   float x2 };
  15 type record of octetstring setofOper_trecof;
  16 type set setofOper_tset {
  17   integer x1,
  18   float x2 optional };
  19 type set of charstring setofOper_tsetof;
  20 type union setofOper_tunion {
  21   integer x1,
  22   float x2 };
  23 type set of integer setofOper_mysetof1;         // set of basic types
  24 type set of setofOper_myenum setofOper_mysetof2; // set of enum
  25 type set of setofOper_trecord setofOper_mysetof3;  // set of record
  26 type set of setofOper_trecof setofOper_mysetof4; // set of record of
  27 type set of setofOper_tset setofOper_mysetof5;  // set of set
  28 type set of setofOper_tsetof setofOper_mysetof6; // set of set of
  29 type set of setofOper_tunion setofOper_mysetof7; // set of union
  30 // *************** Constanst ***********************
  31 const setofOper_trecord setofOper_temp1:={ x1:=omit, x2:=3.4 };
  32 const setofOper_trecof setofOper_temp2:={ 'AF12'O };
  33 const setofOper_tset setofOper_temp3:={ x1:=234, x2:=1.9};
  34 const setofOper_tsetof setofOper_temp4:={"f","8"};
  35 const setofOper_tunion setofOper_temp5:={ x2:=1.3 };
  36 const setofOper_mysetof1 setofOper_const1:={ 1,2 }      //set of basic types
  37 const setofOper_mysetof2 setofOper_const2:={ xx2, xx1 }
  38 const setofOper_mysetof3 setofOper_const4:={   //set of record
  39   { x1:=1, x2:=1.2 },setofOper_temp1 };
  40 const setofOper_mysetof4 setofOper_const6:={   //set of record of
  41   { '12AB'O, 'CD12'O },  setofOper_temp2 };
  42 const setofOper_mysetof5 setofOper_const8:={   //set of set
  43   { x1:=2, x2:=1.3}, setofOper_temp3 };
  44 const setofOper_mysetof6 setofOper_const10:={   //set of set of
  45   {"a","b"}, setofOper_temp4 }; //{"f","8"},
  46 const setofOper_mysetof7 setofOper_const12:={   //set of union
  47   { x1 :=3 }, setofOper_temp5  }; //{ x2:=1.3 }
  48
  49 testcase setofAssign() runs on setofOper_mycomp{
  50   var setofOper_mysetof1 x1:={ 12,34}   //set of basic types
  51   var setofOper_mysetof1 x2,x3,x4;
  52   x2:={ 32, 12 };
  53   x3:={32};
  54   x3:={32,12};
  55   x4:={};
  56   if (x1[0]==12) {setverdict(pass);}    //at declaration
  57   else {setverdict(fail);}
  58   if (x1[1]==34) {setverdict(pass);}
  59   else {setverdict(fail);}
  60   if (x2[0]==32) {setverdict(pass);}    //later
  61   else {setverdict(fail);}
  62   if (x2[1]==12) {setverdict(pass);}
  63   else {setverdict(fail);}
  64   if (x3[0]==32) {setverdict(pass);}    //later, change of size
  65   else {setverdict(fail);}
  66   if (x3[1]==12) {setverdict(pass);}
  67   else {setverdict(fail);}
  68   //if (x4=={}) {setverdict(pass);}             // empty set of
  69   //     else {setverdict(fail);}
  70 }
  71
  72 testcase setofAssignEnum() runs on setofOper_mycomp{
  73   var setofOper_mysetof2 x1:={ xx2 }    //set of enum
  74   var setofOper_mysetof2 x2;
  75   x2:={xx2,xx1};
  76   //at declaration
  77   if (x1[0]==xx2) {setverdict(pass);}
  78   else {setverdict(fail);}
  79   //later
  80   if (x2[0]==xx2) {setverdict(pass);}
  81   else {setverdict(fail);}
  82   if (x2[1]==xx1) {setverdict(pass);}
  83   else {setverdict(fail);}
  84 }
  85
  86 testcase setofAssignRec() runs on setofOper_mycomp{
  87   var setofOper_trecord temp1:={ x1:=omit, x2:=3.4 };
  88   var setofOper_mysetof3 x1:={   //set of record
  89     { x1:=1, x2:=1.2 }, temp1 };
  90   var setofOper_mysetof3 x2;
  91   x2:={ { x1:=1, x2:=1.2 }, temp1 };
  92   if (x1[0].x1==1) {setverdict(pass);}  //at declaration
  93   else {setverdict(fail);}
  94   if (x1[0].x2==1.2) {setverdict(pass);}
  95   else {setverdict(fail);}
  96   if (x1[1]==temp1) {setverdict(pass);}
  97   else {setverdict(fail);}
  98   if (x2[0].x1==1) {setverdict(pass);}  //later
  99   else {setverdict(fail);}
 100   if (x2[0].x2==1.2) {setverdict(pass);}
 101   else {setverdict(fail);}
 102   if (not(ispresent(x2[1].x1))) {setverdict(pass);}
 103   else {setverdict(fail);}
 104   if (x2[1].x2==3.4) {setverdict(pass);}
 105   else {setverdict(fail);}
 106 }
 107
 108 testcase setofAssignRecof() runs on setofOper_mycomp{
 109   var setofOper_trecof temp2:={'AF12'O};
 110   var setofOper_mysetof4 x1:={   //set of record of
 111     { '12AB'O, 'CD12'O }, temp2 };
 112   var setofOper_mysetof4 x2;
 113   x2:={ { '12AB'O, 'CD12'O }, temp2 };
 114   if (x1[0][0]=='12AB'O) {setverdict(pass);}    //at declaration
 115   else {setverdict(fail);}
 116   if (x1[0][1]=='CD12'O) {setverdict(pass);}
 117   else {setverdict(fail);}
 118   if (x1[1]==temp2) {setverdict(pass);}
 119   else {setverdict(fail);}
 120   if (x2[0][0]=='12AB'O) {setverdict(pass);}    //later
 121   else {setverdict(fail);}
 122   if (x2[0][1]=='CD12'O) {setverdict(pass);}
 123   else {setverdict(fail);}
 124   if (x2[1][0]=='AF12'O) {setverdict(pass);}
 125   else {setverdict(fail);}
 126 }
 127
 128 testcase setofAssignSet() runs on setofOper_mycomp{
 129   var setofOper_tset temp1:={ x1:=2, x2:=omit };
 130   var setofOper_mysetof5 x1:={   //set of set
 131     { x1:=1, x2:=1.2 }, temp1 };
 132   var setofOper_mysetof5 x2;
 133   x2:={ { x1:=1, x2:=1.2 }, temp1 };
 134   if (x1[0].x1==1) {setverdict(pass);}  //at declaration
 135   else {setverdict(fail);}
 136   if (x1[0].x2==1.2) {setverdict(pass);}
 137   else {setverdict(fail);}
 138   if (x1[1]==temp1) {setverdict(pass);}
 139   else {setverdict(fail);}
 140   if (x2[0].x1==1) {setverdict(pass);}  //later
 141   else {setverdict(fail);}
 142   if (x2[0].x2==1.2) {setverdict(pass);}
 143   else {setverdict(fail);}
 144   if (x2[1].x1==2) {setverdict(pass);}
 145   else {setverdict(fail);}
 146   if (not(ispresent(x2[1].x2))) {setverdict(pass);}
 147   else {setverdict(fail);}
 148 }
 149
 150 testcase setofAssignSetof() runs on setofOper_mycomp{
 151   var setofOper_tsetof temp2:={"a","7"};
 152   var setofOper_mysetof6 x1:={   //set of set of
 153     { "1", "a" }, temp2 };
 154   var setofOper_mysetof6 x2;
 155   x2:={ { "1", "a" }, temp2 };
 156   if (x1[0][0]=="1") {setverdict(pass);}        //at declaration
 157   else {setverdict(fail);}
 158   if (x1[0][1]=="a") {setverdict(pass);}
 159   else {setverdict(fail);}
 160   if (x1[1]==temp2) {setverdict(pass);}
 161   else {setverdict(fail);}
 162   if (x2[0][0]=="1") {setverdict(pass);}        //later
 163   else {setverdict(fail);}
 164   if (x2[0][1]=="a") {setverdict(pass);}
 165   else {setverdict(fail);}
 166   if (x2[1][0]=="a") {setverdict(pass);}
 167   else {setverdict(fail);}
 168   if (x2[1][1]=="7") {setverdict(pass);}
 169   else {setverdict(fail);}
 170 }
 171
 172 testcase setofAssignUnion() runs on setofOper_mycomp{
 173   var setofOper_tunion temp5 := {x2:=1.3}
 174   var setofOper_mysetof7 x1:={   //set of union
 175     { x1 :=3 }, temp5  }; //{ x2:=1.3
 176   var setofOper_mysetof7 x2;
 177   x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
 178   if (x1[0].x1==3) {setverdict(pass);}  //at declaration
 179   else {setverdict(fail);}
 180   if (ischosen(x1[0].x1)) {setverdict(pass);}
 181   else {setverdict(fail);}
 182   if (not(ischosen(x1[0].x2))) {setverdict(pass);}
 183   else {setverdict(fail);}
 184   if (x1[1]==temp5) {setverdict(pass);}
 185   else {setverdict(fail);}
 186   if (x2[0].x1==3) {setverdict(pass);}  //later
 187   else {setverdict(fail);}
 188   if (ischosen(x2[0].x1)) {setverdict(pass);}
 189   else {setverdict(fail);}
 190   if (not(ischosen(x2[0].x2))) {setverdict(pass);}
 191   else {setverdict(fail);}
 192   if (x2[1].x2==1.3) {setverdict(pass);}
 193   else {setverdict(fail);}
 194   if (ischosen(x2[1].x2)) {setverdict(pass);}
 195   else {setverdict(fail);}
 196   if (not(ischosen(x2[1].x1))) {setverdict(pass);}
 197   else {setverdict(fail);}
 198 }
 199
 200 testcase setofAssignElem() runs on setofOper_mycomp{
 201   var setofOper_mysetof1 x1,x2,x3,x4,x5;        //set of basic types
 202   x1:={ 3, 2 };
 203   x2:={ 1, 2 };
 204   x3:=x2;
 205   x4:=x2;
 206   x5:={2};
 207   x2[0]:=3;                     //change element to value
 208   x3[0]:=x1[0];                 //change element to element
 209   x4[2]:=2;                     // add element
 210   x5[2]:=3;                     // out of order
 211   if (x1[1]==2) {setverdict(pass);}     //accessing individual element
 212   else {setverdict(fail);}
 213   if (x2[0]==3) {setverdict(pass);}     // change element to value
 214   else {setverdict(fail);}
 215   if (x2[1]==2) {setverdict(pass);}
 216   else {setverdict(fail);}
 217   if (x3[0]==3) {setverdict(pass);}     // change element to element
 218   else {setverdict(fail);}
 219   if (x3[1]==2) {setverdict(pass);}
 220   else {setverdict(fail);}
 221   if (x4[0]==1) {setverdict(pass);}     // add element
 222   else {setverdict(fail);}
 223   if (x4[1]==2) {setverdict(pass);}
 224   else {setverdict(fail);}
 225   if (x4[2]==2) {setverdict(pass);}
 226   else {setverdict(fail);}
 227   if (x5[2]==3) {setverdict(pass);}     // out of order
 228   else {setverdict(fail);}
 229 }
 230
 231 testcase setofAssignElemEnum() runs on setofOper_mycomp{
 232   var setofOper_mysetof2 x1:={ xx1, xx2 };      //set of enumerated
 233   var setofOper_mysetof2 x2, x3;
 234   x2:={ xx1, xx2 }
 235   x1[0]:=xx3;                   //change element
 236   x2[2]:=xx3;                   // add element
 237   x3[2]:=xx3;                   // out of order
 238   if (x1[0]==xx3) {setverdict(pass);}   // change element
 239   else {setverdict(fail);}
 240   if (x1[1]==xx2) {setverdict(pass);}
 241   else {setverdict(fail);}
 242   if (x2[0]==xx1) {setverdict(pass);}   // add element
 243   else {setverdict(fail);}
 244   if (x2[1]==xx2) {setverdict(pass);}
 245   else {setverdict(fail);}
 246   if (x2[2]==xx3) {setverdict(pass);}
 247   else {setverdict(fail);}
 248   if (x3[2]==xx3) {setverdict(pass);}   // out of order
 249   else {setverdict(fail);}
 250 }
 251
 252 testcase setofAssignElemRec() runs on setofOper_mycomp{
 253   var setofOper_mysetof3 x1,x2,x3;      //set of record
 254   x1:={   { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
 255   x2:=x1;
 256   x1[0].x1:=2;
 257   //temp1.x1:=3;
 258   x1[1].x1:=3;
 259   x2[2]:= {x1:=2, x2:=1.3};             // add element
 260   x3[1]:= {x1:=2, x2:=1.3};             //out of order
 261   if (x1[0].x1==2) {setverdict(pass);}  // change element
 262   else {setverdict(fail);}
 263   if (x1[0].x2==1.2) {setverdict(pass);}
 264   else {setverdict(fail);}
 265   if (x1[1].x1==3) {setverdict(pass);}
 266   else {setverdict(fail);}
 267   if (x1[1].x2==3.4) {setverdict(pass);}
 268   else {setverdict(fail);}
 269   if (x2[0].x1==1) {setverdict(pass);}  //add element
 270   else {setverdict(fail);}
 271   if (x2[0].x2==1.2) {setverdict(pass);}
 272   else {setverdict(fail);}
 273   if (not(ispresent(x2[1].x1))) {setverdict(pass);}
 274   else {setverdict(fail);}
 275   if (x2[1].x2==3.4) {setverdict(pass);}
 276   else {setverdict(fail);}
 277   if (x2[2].x1==2) {setverdict(pass);}
 278   else {setverdict(fail);}
 279   if (x2[2].x2==1.3) {setverdict(pass);}
 280   else {setverdict(fail);}
 281   if (x3[1].x1==2) {setverdict(pass);}     // out of order
 282   else {setverdict(fail);}
 283   if (x3[1].x2==1.3) {setverdict(pass);}
 284   else {setverdict(fail);}
 285 }
 286
 287
 288 testcase setofAssignElemRecof() runs on setofOper_mycomp{
 289   var setofOper_mysetof4 x1,x2,x3;               //set of record of
 290   x1:={  { '12AB'O, 'CD12'O }, { 'ABCD'O } };
 291   x2:=x1;
 292   x1[0][1]:='34AB'O;            //change element
 293   x2[2]:={ '1234'O};            //add element
 294   x3[2]:={'12CD'O};             //out of order
 295   if (x1[0][0]=='12AB'O) {setverdict(pass);}    // change element
 296   else {setverdict(fail);}
 297   if (x1[0][1]=='34AB'O) {setverdict(pass);}
 298   else {setverdict(fail);}
 299   if (x1[1][0]=='ABCD'O) {setverdict(pass);}
 300   else {setverdict(fail);}
 301   if (x2[0][0]=='12AB'O) {setverdict(pass);}    // add element
 302   else {setverdict(fail);}
 303   if (x2[0][1]=='CD12'O) {setverdict(pass);}
 304   else {setverdict(fail);}
 305   if (x2[1][0]=='ABCD'O) {setverdict(pass);}
 306   else {setverdict(fail);}
 307   if (x2[2][0]=='1234'O) {setverdict(pass);}
 308   else {setverdict(fail);}
 309   if (x3[2][0]=='12CD'O) {setverdict(pass);}    //out of order
 310   else {setverdict(fail);}
 311 }
 312
 313 testcase setofAssignElemSet() runs on setofOper_mycomp{
 314   var setofOper_mysetof5 x1,x2,x3               //set of set
 315   x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
 316   x2:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
 317   x1[0].x2:=3.4;                                //change element
 318   x2[2]:={  x1:=2, x2:=1.3 };           // add element
 319   x3[2]:={  x1:=2, x2:=1.3 };           // out of order
 320   if (x1[0].x1==1) {setverdict(pass);}  //change element
 321   else {setverdict(fail);}
 322   if (x1[0].x2==3.4) {setverdict(pass);}
 323   else {setverdict(fail);}
 324   if (x1[1].x1==2) {setverdict(pass);}
 325   else {setverdict(fail);}
 326   if (not(ispresent(x1[1].x2))) {setverdict(pass);}
 327   else {setverdict(fail);}
 328   if (x2[0].x1==1) {setverdict(pass);}  //add element
 329   else {setverdict(fail);}
 330   if (x2[0].x2==1.2) {setverdict(pass);}
 331   else {setverdict(fail);}
 332   if (x2[1].x1==2) {setverdict(pass);}
 333   else {setverdict(fail);}
 334   if (not(ispresent(x2[1].x2))) {setverdict(pass);}
 335   else {setverdict(fail);}
 336   if (x2[2].x1==2) {setverdict(pass);}
 337   else {setverdict(fail);}
 338   if (x2[2].x2==1.3) {setverdict(pass);}
 339   else {setverdict(fail);}
 340   if (x3[2].x1==2) {setverdict(pass);}  //out of order
 341   else {setverdict(fail);}
 342   if (x3[2].x2==1.3) {setverdict(pass);}
 343   else {setverdict(fail);}
 344 }
 345
 346 testcase setofAssignElemSetof() runs on setofOper_mycomp{
 347   var setofOper_tsetof temp2:={"a","7"};
 348   var setofOper_mysetof6 x1,x2,x3;   //set of set of
 349   x1:={ { "1" }, {"a","7"}};
 350   x2:={ { "1" }, {"a","7"}};
 351   x1[0][0]:="h";                        // change element
 352   x2[2]:={"2"};                 //add element
 353   x3[2]:={"2"};                 //out of order
 354   if (x1[0][0]=="h") {setverdict(pass);}          //change element
 355   else {setverdict(fail);}
 356   if (x1[1][0]=="a") {setverdict(pass);}
 357   else {setverdict(fail);}
 358   if (x1[1][1]=="7") {setverdict(pass);}
 359   else {setverdict(fail);}
 360   if (x2[0][0]=="1") {setverdict(pass);}          //add element
 361   else {setverdict(fail);}
 362   if (x2[1][0]=="a") {setverdict(pass);}
 363   else {setverdict(fail);}
 364   if (x2[1][1]=="7") {setverdict(pass);}
 365   else {setverdict(fail);}
 366   if (x2[2][0]=="2") {setverdict(pass);}
 367   else {setverdict(fail);}
 368   if (x3[2][0]=="2") {setverdict(pass);}                // out of order
 369   else {setverdict(fail);}
 370 }
 371
 372 testcase setofAssignElemUnion() runs on setofOper_mycomp{
 373   var setofOper_tunion temp5 := {x2:=1.3}
 374   var setofOper_mysetof7 x1,x2,x3;   //set of union
 375   x1:={ {x1 :=3 }, {x2:=1.3} };
 376   x2:={ {x1 :=3 }, {x2:=1.3} };
 377   x1[0].x2:=3.4;                        //change element
 378   x2[2]:={ x2:=1.4};            // add element
 379   x3[2]:={ x2:=1.4};            // out of order
 380   if (x1[0].x2==3.4) {setverdict(pass);}                //change element
 381   else {setverdict(fail);}
 382   if (ischosen(x1[0].x2)) {setverdict(pass);}
 383   else {setverdict(fail);}
 384   if (not(ischosen(x1[0].x1))) {setverdict(pass);}
 385   else {setverdict(fail);}
 386   if (x1[1].x2==1.3) {setverdict(pass);}
 387   else {setverdict(fail);}
 388   if (ischosen(x1[1].x2)) {setverdict(pass);}
 389   else {setverdict(fail);}
 390   if (not(ischosen(x1[1].x1))) {setverdict(pass);}
 391   else {setverdict(fail);}
 392   if (x2[0].x1==3) {setverdict(pass);}          //add element
 393   else {setverdict(fail);}
 394   if (ischosen(x2[0].x1)) {setverdict(pass);}
 395   else {setverdict(fail);}
 396   if (not(ischosen(x2[0].x2))) {setverdict(pass);}
 397   else {setverdict(fail);}
 398   if (x2[1].x2==1.3) {setverdict(pass);}
 399   else {setverdict(fail);}
 400   if (ischosen(x2[1].x2)) {setverdict(pass);}
 401   else {setverdict(fail);}
 402   if (not(ischosen(x2[1].x1))) {setverdict(pass);}
 403   else {setverdict(fail);}
 404   if (x2[2].x2==1.4) {setverdict(pass);}
 405   else {setverdict(fail);}
 406   if (ischosen(x2[2].x2)) {setverdict(pass);}
 407   else {setverdict(fail);}
 408   if (not(ischosen(x2[2].x1))) {setverdict(pass);}
 409   else {setverdict(fail);}
 410   if (x3[2].x2==1.4) {setverdict(pass);}                //out of order
 411   else {setverdict(fail);}
 412   if (ischosen(x3[2].x2)) {setverdict(pass);}
 413   else {setverdict(fail);}
 414   if (not(ischosen(x3[2].x1))) {setverdict(pass);}
 415   else {setverdict(fail);}
 416 }
 417
 418 testcase setofConst() runs on setofOper_mycomp{
 419   const setofOper_mysetof1 const1:={1,2,3} //set of basic types
 420   if (setofOper_const1[0]==1) {setverdict(pass);}       //definition part
 421   else {setverdict(fail);}
 422   if (setofOper_const1[1]==2) {setverdict(pass);}
 423   else {setverdict(fail);}
 424   if (const1[0]==1) {setverdict(pass);} //testcase
 425   else {setverdict(fail);}
 426   if (const1[1]==2) {setverdict(pass);}
 427   else {setverdict(fail);}
 428   if (const1[2]==3) {setverdict(pass);}
 429   else {setverdict(fail);}
 430 }
 431
 432 testcase setofConstEnum() runs on setofOper_mycomp{
 433   const setofOper_mysetof2 const1:={xx1,xx2,xx3} //set of enumerated
 434   if (setofOper_const2[0]==xx2) {setverdict(pass);}     //definition part
 435   else {setverdict(fail);}
 436   if (setofOper_const2[1]==xx1) {setverdict(pass);}
 437   else {setverdict(fail);}
 438   if (const1[0]==xx1) {setverdict(pass);}       //testcase
 439   else {setverdict(fail);}
 440   if (const1[1]==xx2) {setverdict(pass);}
 441   else {setverdict(fail);}
 442   if (const1[2]==xx3) {setverdict(pass);}
 443   else {setverdict(fail);}
 444 }
 445
 446 testcase setofConstRec() runs on setofOper_mycomp{
 447   const setofOper_mysetof3 const4:={   //set of record
 448     { x1:=1, x2:=1.2 }, setofOper_temp1 };
 449   if (setofOper_const4[0].x1==1) {setverdict(pass);}    //definition part
 450   else {setverdict(fail);}
 451   if (setofOper_const4[0].x2==1.2) {setverdict(pass);}
 452   else {setverdict(fail);}
 453   if (setofOper_const4[1]==setofOper_temp1) {setverdict(pass);}
 454   else {setverdict(fail);}
 455   if (const4[0].x1==1) {setverdict(pass);}      //testcase
 456   else {setverdict(fail);}
 457   if (const4[0].x2==1.2) {setverdict(pass);}
 458   else {setverdict(fail);}
 459   if (const4[1]==setofOper_temp1) {setverdict(pass);}
 460   else {setverdict(fail);}
 461 }
 462
 463 testcase setofConstRecof() runs on setofOper_mycomp{
 464   const setofOper_mysetof4 const6:={   //set of record of
 465     { '12AB'O, 'CD12'O }, setofOper_temp2 };
 466   if (setofOper_const6[0][0]=='12AB'O) {setverdict(pass);}      //definition part
 467   else {setverdict(fail);}
 468   if (setofOper_const6[0][1]=='CD12'O) {setverdict(pass);}
 469   else {setverdict(fail);}
 470   if (setofOper_const6[1]==setofOper_temp2) {setverdict(pass);}
 471   else {setverdict(fail);}
 472   if (const6[0][0]=='12AB'O) {setverdict(pass);}        //testcase
 473   else {setverdict(fail);}
 474   if (const6[0][1]=='CD12'O) {setverdict(pass);}
 475   else {setverdict(fail);}
 476   if (const6[1]==setofOper_temp2) {setverdict(pass);}
 477   else {setverdict(fail);}
 478 }
 479
 480 testcase setofConstSet() runs on setofOper_mycomp{
 481   const setofOper_mysetof5 const8:={   //set of set
 482     { x1:=2, x2:=1.3}, setofOper_temp3 };
 483   if (setofOper_const8[0].x1==2) {setverdict(pass);}    //definition part
 484   else {setverdict(fail);}
 485   if (setofOper_const8[0].x2==1.3) {setverdict(pass);}
 486   else {setverdict(fail);}
 487   if (setofOper_const8[1]==setofOper_temp3) {setverdict(pass);}
 488   else {setverdict(fail);}
 489   if (const8[0].x1==2) {setverdict(pass);}      //testcase
 490   else {setverdict(fail);}
 491   if (const8[0].x2==1.3) {setverdict(pass);}
 492   else {setverdict(fail);}
 493   if (const8[1]==setofOper_temp3) {setverdict(pass);}
 494   else {setverdict(fail);}
 495 }
 496
 497 testcase setofConstSetof() runs on setofOper_mycomp{
 498   const setofOper_mysetof6 const10:={   //set of set of
 499     {"a","b"}, {"f","8"} };
 500   if (setofOper_const10[0][0]=="a") {setverdict(pass);} //definition part
 501   else {setverdict(fail);}
 502   if (setofOper_const10[0][1]=="b") {setverdict(pass);}
 503   else {setverdict(fail);}
 504   if (setofOper_const10[1]==setofOper_temp4) {setverdict(pass);}
 505   else {setverdict(fail);}
 506   if (const10[0][0]=="a") {setverdict(pass);}   //testcase
 507   else {setverdict(fail);}
 508   if (const10[0][1]=="b") {setverdict(pass);}
 509   else {setverdict(fail);}
 510   if (const10[1][0]=="f") {setverdict(pass);}
 511   else {setverdict(fail);}
 512   if (const10[1][1]=="8") {setverdict(pass);}
 513   else {setverdict(fail);}
 514 }
 515
 516 testcase setofConstUnion() runs on setofOper_mycomp{
 517   const setofOper_mysetof7 const12:={   //set of union
 518     { x1 :=3 }, { x2:=1.3 } };
 519   if (setofOper_const12[0].x1==3) {setverdict(pass);}   //definition part
 520   else {setverdict(fail);}
 521   if (ischosen(setofOper_const12[0].x1)) {setverdict(pass);}
 522   else {setverdict(fail);}
 523   if (not(ischosen(setofOper_const12[0].x2))) {setverdict(pass);}
 524   else {setverdict(fail);}
 525   if (setofOper_const12[1]==setofOper_temp5) {setverdict(pass);}
 526   else {setverdict(fail);}
 527   if (const12[0].x1==3) {setverdict(pass);}     //testcase
 528   else {setverdict(fail);}
 529   if (ischosen(const12[0].x1)) {setverdict(pass);}
 530   else {setverdict(fail);}
 531   if (not(ischosen(const12[0].x2))) {setverdict(pass);}
 532   else {setverdict(fail);}
 533   if (const12[1].x2==1.3) {setverdict(pass);}
 534   else {setverdict(fail);}
 535   if (ischosen(const12[1].x2)) {setverdict(pass);}
 536   else {setverdict(fail);}
 537   if (not(ischosen(const12[1].x1))) {setverdict(pass);}
 538   else {setverdict(fail);}
 539 }
 540
 541 testcase setofConstComp() runs on setofOper_mycomp{
 542   const setofOper_mysetof1 x1:={ 1,2,3 };
 543   const setofOper_mysetof1 x2:={ 1,2,3 };
 544   const setofOper_mysetof1 x3:={ 1,2 };
 545   const setofOper_mysetof1 x4:={ 3,1,2 };
 546   if (x1==x2) {setverdict(pass);}
 547   else {setverdict(fail);}
 548   if (not(x1==x3)) {setverdict(pass);}
 549   else {setverdict(fail);}
 550   if (x4==x2) {setverdict(pass);}       // out of order
 551   else {setverdict(fail);}
 552   if (x1!=x3) {setverdict(pass);}
 553   else {setverdict(fail);}
 554   if (not(x1!=x2)) {setverdict(pass);}
 555   else {setverdict(fail);}
 556   if (not(x4!=x2)) {setverdict(pass);}  // out of order
 557   else {setverdict(fail);}
 558 }
 559
 560 testcase setofComp() runs on setofOper_mycomp{
 561   var setofOper_mysetof1 x1,x2,x3,x4; //set of basic types
 562   x1:={ 1,2,3 };
 563   x2:={ 1,2,3 };
 564   x3:={ 1,2 };
 565   x4:={ 3,1,2 };
 566   if (x1==x2) {setverdict(pass);}
 567   else {setverdict(fail);}
 568   if (not(x1==x3)) {setverdict(pass);}
 569   else {setverdict(fail);}
 570   if (x4==x2) {setverdict(pass);}       // out of order
 571   else {setverdict(fail);}
 572   if (x1!=x3) {setverdict(pass);}
 573   else {setverdict(fail);}
 574   if (not(x1!=x2)) {setverdict(pass);}
 575   else {setverdict(fail);}
 576   if (not(x4!=x2)) {setverdict(pass);}  // out of order
 577   else {setverdict(fail);}
 578 }
 579
 580 testcase setofCompEnum() runs on setofOper_mycomp{
 581   var setofOper_mysetof2 x1,x2,x3,x4;   //set of enumerated
 582   x1:={ xx1,xx2,xx3 };
 583   x2:={ xx1,xx2,xx3 };
 584   x3:={ xx1,xx2 };
 585   x4:={xx3,xx2,xx1};
 586   if (x1==x2) {setverdict(pass);}
 587   else {setverdict(fail);}
 588   if (not(x1==x3)) {setverdict(pass);}
 589   else {setverdict(fail);}
 590   if (x4==x2) {setverdict(pass);}       //out of order
 591   else {setverdict(fail);}
 592   if (x1!=x3) {setverdict(pass);}
 593   else {setverdict(fail);}
 594   if (not(x1!=x2)) {setverdict(pass);}
 595   else {setverdict(fail);}
 596   if (not(x4!=x2)) {setverdict(pass);}  // out of order
 597   else {setverdict(fail);}
 598 }
 599
 600 testcase setofCompRec() runs on setofOper_mycomp{
 601   var setofOper_mysetof3 x1,x2,x3,x4;   // set of record
 602   x1 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
 603   x2 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
 604   x3 :={ { x1:=2, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
 605   x4 :={ { x1:=omit, x2:=3.4 }, { x1:=1, x2:=1.2 } };
 606   if (x1==x2) {setverdict(pass);}
 607   else {setverdict(fail);}
 608   if (not(x1==x3)) {setverdict(pass);}
 609   else {setverdict(fail);}
 610   if (x4==x2) {setverdict(pass);}       //out of order
 611   else {setverdict(fail);}
 612   if (x1!=x3) {setverdict(pass);}
 613   else {setverdict(fail);}
 614   if (not(x1!=x2)) {setverdict(pass);}
 615   else {setverdict(fail);}
 616   if (not(x4!=x2)) {setverdict(pass);}  // out of order
 617   else {setverdict(fail);}
 618 }
 619
 620
 621 testcase setofCompRecof() runs on setofOper_mycomp{
 622   var setofOper_mysetof4 x1,x2,x3,x4; //set of record of
 623   x1:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
 624   x2:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
 625   x3:={ { '12AB'O  }, {'AF12'O} };
 626   x4:={ {'AF12'O}, { '12AB'O, 'CD12'O } };
 627   if (x1==x2) {setverdict(pass);}
 628   else {setverdict(fail);}
 629   if (not(x1==x3)) {setverdict(pass);}
 630   else {setverdict(fail);}
 631   if (x4==x2) {setverdict(pass);}       //out of order
 632   else {setverdict(fail);}
 633   if (x2!=x3) {setverdict(pass);}
 634   else {setverdict(fail);}
 635   if (not(x1!=x2)) {setverdict(pass);}
 636   else {setverdict(fail);}
 637   if (not(x4!=x2)) {setverdict(pass);}  //out of order
 638   else {setverdict(fail);}
 639 }
 640
 641 testcase setofCompSet() runs on setofOper_mycomp{
 642   var setofOper_tset temp1:={ x1:=2, x2:=omit };
 643   var setofOper_mysetof5 x1,x2,x3,x4; //set of set
 644   x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit } };
 645   x2:={ { x2:=1.2, x1:=1 }, { x1:=2, x2:=omit }};
 646   x3:={ { x1:=1, x2:=1.2 } };
 647   x4:={ { x1:=2, x2:=omit }, { x2:=1.2, x1:=1 } };
 648   if (x1==x2) {setverdict(pass);}
 649   else {setverdict(fail);}
 650   if (not(x2==x3)) {setverdict(pass);}
 651   else {setverdict(fail);}
 652   if (x4==x2) {setverdict(pass);}       //out of order
 653   else {setverdict(fail);}
 654   if (x1!=x3) {setverdict(pass);}
 655   else {setverdict(fail);}
 656   if (not(x1!=x2)) {setverdict(pass);}
 657   else {setverdict(fail);}
 658   if (not(x4!=x2)) {setverdict(pass);}  //out of order
 659   else {setverdict(fail);}
 660 }
 661
 662 testcase setofCompSetof() runs on setofOper_mycomp{
 663   var setofOper_tsetof temp2:={"a","7"};
 664   var setofOper_mysetof6 x1,x2,x3,x4;   //set of set of
 665   x1:={ { "1", "a" },  temp2 };
 666   x2:={ { "1", "a" }, {"a","7"} };
 667   x3:={ { "1", "a" } };
 668   x4:={ {"a","7"}, { "1", "a" } };
 669   if (x1==x2) {setverdict(pass);}
 670   else {setverdict(fail);}
 671   if (not(x2==x3)) {setverdict(pass);}
 672   else {setverdict(fail);}
 673   if (x4==x2) {setverdict(pass);}       //out of order
 674   else {setverdict(fail);}
 675   if (x1!=x3) {setverdict(pass);}
 676   else {setverdict(fail);}
 677   if (not(x1!=x2)) {setverdict(pass);}
 678   else {setverdict(fail);}
 679   if (not(x4!=x2)) {setverdict(pass);}  // out of order
 680   else {setverdict(fail);}
 681 }
 682
 683 testcase setofCompUnion() runs on setofOper_mycomp{
 684   var setofOper_tunion temp5 := {x2:=1.3}
 685   var setofOper_mysetof7 x1,x2,x3,x4; //set of union
 686   x1:={ { x1 :=3 }, { x2:=1.3 } };
 687   x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
 688   x3:={ { x2 :=3.9 },temp5 }; //{ x2:=1.3 }
 689   x4:={ { x2:=1.3 }, { x1 :=3 } };
 690   if (x1==x2) {setverdict(pass);}
 691   else {setverdict(fail);}
 692   if (not(x1==x3)) {setverdict(pass);}
 693   else {setverdict(fail);}
 694   if (x4==x2) {setverdict(pass);}       //out of order
 695   else {setverdict(fail);}
 696   if (x2!=x3) {setverdict(pass);}
 697   else {setverdict(fail);}
 698   if (not(x1!=x2)) {setverdict(pass);}
 699   else {setverdict(fail);}
 700   if (not(x4!=x2)) {setverdict(pass);}  //out of order
 701   else {setverdict(fail);}
 702 }
 703
 704 //TR HP50388:
 705 testcase setofCompUnbound() runs on setofOper_mycomp{
 706   var setofOper_mysetof1 x1,x2,x3,x4;
 707   x1 := {[3] := 4};
 708   x2 := {[3] := 4};
 709   x3 := {-,-,-,4};
 710   x4 := {-,4,-,-};
 711   if (x1 == x2) {setverdict(pass);}
 712   else {setverdict(fail);}
 713   if (x1 == x3) {setverdict(pass);}
 714   else {setverdict(fail);}
 715   if (x1 == x4) {setverdict(pass);}
 716   else {setverdict(fail);}
 717 }
 718
 719 testcase setofListOperator() runs on setofOper_mycomp{
 720   var setofOper_mysetof1 x1:={1,2};
 721   var setofOper_mysetof1 x2,x3,x4,x5,x6;        //set of basic types
 722   var setofOper_mysetof1 res1, res2, res3, res4;
 723   x2:={ 1, 2 };
 724   x3:={1};
 725   x4:={1};
 726   x4[1]:=3;
 727   x5:={};
 728   x6[2]:=1;
 729   res1 := x1 & x2;
 730   res2 := x1 & x3;
 731   res3 := x2 & x3 & x5;
 732   res4 := x3 & x4;
 733   if (res1 == {1,2,1,2}) {setverdict(pass);}
 734   else {setverdict(fail);}
 735   if (res2 == {1,2,1}) {setverdict(pass);}
 736   else {setverdict(fail);}
 737   if (res3 == {1,2,1}) {setverdict(pass);}
 738   else {setverdict(fail);}
 739   if (res4 == {1,1,3}) {setverdict(pass);}
 740   else {setverdict(fail);}
 741 }
 742
 743 testcase setofRotateOperators() runs on setofOper_mycomp{
 744   var setofOper_mysetof1 x1:={1,2,3,4,5};
 745   var setofOper_mysetof1 x2,x3,x4,x5,x6,x7;     //set of basic types
 746   x2 := x1 <@ 1;
 747   x3 := x1 <@ 10;
 748   x4 := x1 <@ 3 <@ 2;
 749   x5 := x1 @> 1;
 750   x6 := x1 @> 10;
 751   x7 := x1 @> 3 @> 2;
 752   if (x2 == x1) {setverdict(pass);}
 753   else {setverdict(fail);}
 754   if (x3 == x1) {setverdict(pass);}
 755   else {setverdict(fail);}
 756   if (x4 == x1) {setverdict(pass);}
 757   else {setverdict(fail);}
 758   if (x5 == x1) {setverdict(pass);}
 759   else {setverdict(fail);}
 760   if (x6 == x1) {setverdict(pass);}
 761   else {setverdict(fail);}
 762   if (x7 == x1) {setverdict(pass);}
 763   else {setverdict(fail);}
 764 }
 765
 766 testcase setofLengthof() runs on setofOper_mycomp{
 767 // lengthof returns the sequential number of the last initialized element of the set of list type
 768   var setofOper_mysetof1 x1:={1,2};
 769   var setofOper_mysetof1 x2,x3,x4,x5,x6;        //set of basic types
 770   x2:={ 1, 2 };
 771   x3:={1};
 772   x4:={1};
 773   x3:={1,2};                                                            //change size by assignment
 774   x4[1]:=3;                                                                     //change size by adding element
 775   x5:={};                                                                       //empty set of
 776   x6[2]:=1;                                                                     //out of order
 777   if (lengthof(x1)==2) {setverdict(pass);}      //assignment at declaration
 778   else {setverdict(fail);}
 779   if (lengthof(x2)==2) {setverdict(pass);}      //assignment later
 780   else {setverdict(fail);}
 781   if (lengthof(x3)==2) {setverdict(pass);}      //change size by assignment
 782   else {setverdict(fail);}
 783   if (lengthof(x4)==2) {setverdict(pass);}      //change size by adding element
 784   else {setverdict(fail);}
 785   if (lengthof(x5)==0) {setverdict(pass);}      //empty set of
 786   else {setverdict(fail);}
 787   if (lengthof(x6)==3) {setverdict(pass);}      //out of order
 788   else {setverdict(fail);}
 789 }
 790
 791 testcase setofSizeof() runs on setofOper_mycomp{
 792   var setofOper_mysetof1 x1:={1,2};
 793   var setofOper_mysetof1 x2,x3,x4,x5,x6;        //set of basic types
 794   x2:={ 1, 2 };
 795   x3:={1};
 796   x4:={1};
 797   x3:={1,2};            //change size by assignment
 798   x4[1]:=3;             //change size by adding element
 799   x5:={};                       //empty set of
 800   x6[2]:=1;             //out of order
 801   if (sizeof(x1)==2) {setverdict(pass);}        //assignment at declaration
 802   else {setverdict(fail);}
 803   if (sizeof(x2)==2) {setverdict(pass);}        //assignment later
 804   else {setverdict(fail);}
 805   if (sizeof(x3)==2) {setverdict(pass);}        //change size by assignment
 806   else {setverdict(fail);}
 807   if (sizeof(x4)==2) {setverdict(pass);}        //change size by adding element
 808   else {setverdict(fail);}
 809   if (sizeof(x5)==0) {setverdict(pass);}        //empty set of
 810   else {setverdict(fail);}
 811   if (sizeof(x6)==3) {setverdict(pass);}        //out of order
 812   else {setverdict(fail);}
 813 }
 814
 815 testcase setofReplace() runs on setofOper_mycomp{
 816   var setofOper_mysetof1 x1:={1,2,3,4,5};
 817   var setofOper_mysetof1 a:={8,8,8};
 818   var setofOper_mysetof1 x2;
 819   x2 := replace(x1,2,3,a);
 820   if (x2 == {1,2,8,8,8}) {setverdict(pass);}
 821   else {setverdict(fail);}
 822 }
 823
 824 testcase setofSubstr() runs on setofOper_mycomp{
 825   var setofOper_mysetof1 x1:={1,2,3,4,5};
 826   var setofOper_mysetof1 x2;
 827   x2 := substr(x1,2,3);
 828   if (x2 == {3,4,5}) {setverdict(pass);}
 829   else {setverdict(fail);}
 830 }
 831
 832 type record intsetrec { setofOper_mysetof1 a }
 833 type set of intsetrec intsetreclist
 834
 835 testcase setofIsvalue() runs on setofOper_mycomp {
 836   var setofOper_mysetof1 v_def;
 837   var setofOper_mysetof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
 838   var setofOper_mysetof1 v_full := {1,2,3,4,5,6,7,8,9,10}
 839
 840   if ( isvalue(v_def) ) { setverdict(fail); } else { setverdict(pass); };
 841   if ( isvalue(v_empty) ) { setverdict(fail); } else { setverdict(pass); };
 842   if ( isvalue(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
 843   if ( isvalue(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
 844   if ( isvalue(v_full) ) { setverdict(pass); } else { setverdict(fail); };
 845
 846   v_def[1] := 3;
 847
 848   if ( isvalue(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
 849   if ( isvalue(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
 850   if ( isvalue(v_def) ) { setverdict(fail); } else { setverdict(pass); };
 851
 852
 853   template intsetreclist ist1 := { { a := { 1, 2, 3 } } };
 854   template intsetreclist ist2 modifies ist1 := { { a := { 1, 2, -, -, -, 100 } } }
 855   template intsetrec istt1                := { a := { 1, 2, 3 } }
 856   template intsetrec istt2 modifies istt1 := { a := { 1, 2, -, -, -, 100 } }
 857
 858   if (isvalue (ist1)) { setverdict ( pass );
 859   } else { setverdict ( fail ); }
 860   if (isvalue (ist2)) { setverdict ( fail ); }
 861   else { setverdict(pass); }
 862   if (isvalue (istt1)) { setverdict ( pass );}
 863   else { setverdict ( fail ); }
 864   if (isvalue (istt2)) { setverdict ( fail ); }
 865   else { setverdict(pass); }
 866 }
 867
 868 testcase setofIsvalue2() runs on setofOper_mycomp {
 869   var setofOper_mysetof1 v;
 870   if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
 871
 872   v[3] := 3;
 873   if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
 874
 875   v[2] := 2;
 876   if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
 877
 878   v[1] := 1;
 879   if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
 880
 881   v[0] := 0;
 882   if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };
 883
 884   v[4] := 4;
 885   if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };
 886
 887   v[6] := 6; // there is now a hole at 5
 888   if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
 889 }
 890
 891 testcase setofIsbound() runs on setofOper_mycomp {
 892   var setofOper_mysetof1 v_def;
 893   var setofOper_mysetof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
 894   var setofOper_mysetof1 v_full := {1,2,3,4,5,6,7,8,9,10}
 895
 896   if ( isbound(v_def) ) { setverdict(fail); } else { setverdict(pass); };
 897   if ( isbound(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
 898   if ( isbound(v_empty) ) { setverdict(pass); } else { setverdict(fail); };
 899   if ( isbound(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
 900   if ( isbound(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
 901   if ( isbound(v_full) ) { setverdict(pass); } else { setverdict(fail); };
 902
 903   v_def[1] := 3;
 904
 905   if ( isbound(v_def) ) { setverdict(pass); } else { setverdict(fail); };
 906   if ( isbound(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
 907   if ( isbound(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
 908   if ( isbound(v_def[10]) ) { setverdict(fail); } else { setverdict(pass); };
 909
 910
 911   template intsetreclist ist1 := { { a := { 1, 2, 3 } } };
 912   template intsetreclist ist2 modifies ist1 := { { a := { 1, 2, -, -, -, 100 } } }
 913   template intsetrec istt1                := { a := { 1, 2, 3 } }
 914   template intsetrec istt2 modifies istt1 := { a := { 1, 2, -, -, -, 100 } }
 915
 916   if (isbound (ist1)) { setverdict(pass); } else { setverdict(fail); };
 917   if (isbound (ist2)) { setverdict(pass); } else { setverdict(fail); };
 918   if (isbound (istt1)) { setverdict(pass); } else { setverdict(fail); };
 919   if (isbound (istt2)) { setverdict(pass); } else { setverdict(fail); };
 920 }
 921
 922 testcase setofCompConst() runs on setofOper_mycomp{
 923   const setofOper_mysetof1 c_s1 := {1,2,3,4};
 924   const setofOper_mysetof1 c_s2 := {4,3,2,1};
 925   const setofOper_mysetof1 c_s3 := {1,3,2,4};
 926   const setofOper_mysetof1 c_s4 := {1,2,3,4,5};
 927   const setofOper_mysetof1 c_s5 := {0,1,2,3,4};
 928   const setofOper_mysetof1 c_s6 := {0,1,2,3,4,5}
 929
 930   const setofOper_mysetof1 c_s1_ind := {[0] := 1,[1] := 2,[2] := 3, [3] := 4};
 931   const setofOper_mysetof1 c_s2_ind := {[0] := 1,[3] := 4,[2] := 3, [1] := 2};
 932   const setofOper_mysetof1 c_s3_ind := {[0] := 2,[3] := 1,[2] := 3, [1] := 4};
 933
 934   var setofOper_mysetof1 vl_s1 := {1,2,3,4};
 935
 936   if(c_s1 == c_s1) {setverdict(pass);}
 937   else {setverdict(fail);}
 938
 939   if(c_s1 == {1,2,3,4}) {setverdict(pass);}
 940   else {setverdict(fail);}
 941
 942   if(c_s1 == {[0] := 1,[1] := 2,[2] := 3, [3] := 4}) {setverdict(pass);}
 943   else {setverdict(fail);}
 944
 945   if(c_s1 == c_s1_ind)  {setverdict(pass);}
 946   else {setverdict(fail);}
 947
 948   if(c_s1_ind == c_s2_ind)  {setverdict(pass);}
 949   else {setverdict(fail);}
 950
 951   if(c_s1_ind == c_s3_ind)  {setverdict(pass);}
 952   else {setverdict(fail);}
 953
 954   if(c_s1 == c_s3_ind)  {setverdict(pass);}
 955   else {setverdict(fail);}
 956
 957   if(c_s2_ind == c_s3_ind)  {setverdict(pass);}
 958   else {setverdict(fail);}
 959
 960   if(c_s1 == vl_s1) {setverdict(pass);}
 961   else {setverdict(fail);}
 962
 963   if(c_s1 == c_s2) {setverdict(pass);}
 964   else {setverdict(fail);}
 965
 966   if(c_s1 == c_s3) {setverdict(pass);}
 967   else {setverdict(fail);}
 968
 969   if(c_s1 != c_s4) {setverdict(pass);}
 970   else {setverdict(fail);}
 971
 972   if(c_s1 != c_s5) {setverdict(pass);}
 973   else {setverdict(fail);}
 974
 975   if(c_s1 != c_s6) {setverdict(pass);}
 976   else {setverdict(fail);}
 977
 978   if(c_s5 != c_s6) {setverdict(pass);}
 979   else {setverdict(fail);}
 980
 981 }
 982
 983 type set length(5) of set length(6) of charstring StringSetArray length(12)
 984 type set length(4) of charstring MySetof1 length(2)
 985 type set of charstring MySetof2 ("a", "aa", "aaa", "aaaa") length(2)
 986 type set length(2) of charstring MySetof3 ("a", "aa", "aaa", "aaaa")
 987 type set length(2) of charstring MySetof4 ("a", "aa", "aaa", "aaaa") length(2)
 988 // TODO: Add additional subtypes here.
 989 type MySetof2 MySetof5
 990 type MySetof3 MySetof6
 991 type MySetof4 MySetof7
 992 type set of record { charstring id length(2), charstring val length(2) } GenericParameters1
 993 type GenericParameters1[-] GenericParameters2 ({"aa", "aa"})
 994 type GenericParameters1[-] GenericParameters3 ({"aa", "aa"})
 995 // FATAL_ERROR() with R8B: `const GenericParameters1[-] c_pars1 := {c_mysetof6[0], valueof(t_mysetof7[0])}'.
 996 // Possibly the same FATAL_ERROR(): `template MySetof2 t_mysetof8 := {"aa", t_mysetof7[0]} length(2)'.
 997 // `MySetof2' doesn't have a subtype? `type MySetof2 MySetof8 (MySetof2)'
 998 type MySetof3 MySetof8 (MySetof3, MySetof3, MySetof3)
 999
1000 const MySetof2 c_mysetof1 := {}
1001 const MySetof2 c_mysetof2 := {"aa", "aa"}
1002 const MySetof2 c_mysetof3 := {c_mysetof2[0], c_mysetof2[1]}
1003 const MySetof3 c_mysetof4 := {"a", "aa"}
1004 const MySetof3 c_mysetof5 := {c_mysetof4[0], c_mysetof4[1]}
1005 const MySetof4 c_mysetof6 := {"aa", "aa"}
1006 const MySetof4 c_mysetof7 := {c_mysetof6[0], c_mysetof6[1]}
1007
1008 template MySetof2 t_mysetof1 := {}
1009 template MySetof2 t_mysetof2 := {"aa", "aa"}
1010 template MySetof2 t_mysetof3 := c_mysetof2
1011 template MySetof3 t_mysetof4 := {"a", "aa"}
1012 template MySetof3 t_mysetof5 := c_mysetof5
1013 template MySetof4 t_mysetof6 := {"aa", "aa"}
1014 template MySetof4 t_mysetof7 := c_mysetof7
1015 template MySetof2 t_mysetof8 := {"aa", c_mysetof7[0]} length(2)
1016 template MySetof8 t_mysetof9 := {"aa" & "aa", "aa"}
1017
1018 testcase setofSubtypes() runs on setofOper_mycomp {
1019   var template MySetof1 vt_mysetof1 := {"AA", "AB", "BA", "BB"}
1020   var MySetof1 v_mysetof1 := {"AA", "AB", "BA", "BB"}
1021   // TITAN compiles this.
1022   if (substr(v_mysetof1, 0, 2) == {"AA", "AB"} and {"BA", "BB"} == substr(valueof(vt_mysetof1), 2, 2)) { setverdict(pass) }
1023   else { setverdict(fail) }
1024 }
1025
1026 control {
1027   const setofOper_trecord cl_temp1:={ x1:=omit, x2:=3.4 }; //constant in control part
1028   const setofOper_trecof cl_temp2:={ 'AF12'O };
1029   const setofOper_tset cl_temp3:={ x1:=234, x2:=1.9};
1030   const setofOper_tsetof cl_temp4:={"f","8"};
1031   const setofOper_tunion cl_temp5:={ x2:=1.3 };
1032   var setofOper_trecord vl_temp1; //variable in control part
1033   var setofOper_trecof vl_temp2;
1034   var setofOper_tset vl_temp3;
1035   var setofOper_tsetof vl_temp4;
1036   var setofOper_tunion vl_temp5;
1037
1038   execute(setofAssign());
1039   execute(setofAssignEnum());
1040   execute(setofAssignRec());
1041   execute(setofAssignRecof());
1042   execute(setofAssignSet());
1043   execute(setofAssignSetof());
1044   execute(setofAssignUnion());
1045   execute(setofAssignElem());
1046   execute(setofAssignElemEnum());
1047   execute(setofAssignElemRec());
1048   execute(setofAssignElemRecof());
1049   execute(setofAssignElemSet());
1050   execute(setofAssignElemSetof());
1051   execute(setofAssignElemUnion());
1052   execute(setofConst());
1053   execute(setofConstEnum());
1054   execute(setofConstRec());
1055   execute(setofConstRecof());
1056   execute(setofConstSet());
1057   execute(setofConstSetof());
1058   execute(setofConstUnion());
1059   execute(setofConstComp());
1060   execute(setofComp());
1061   execute(setofCompConst());
1062   execute(setofCompEnum());
1063   execute(setofCompRec());
1064   execute(setofCompRecof());
1065   execute(setofCompSet());
1066   execute(setofCompSetof());
1067   execute(setofCompUnion());
1068   execute(setofCompUnbound());
1069   execute(setofListOperator());
1070   execute(setofRotateOperators());
1071   execute(setofLengthof());
1072   execute(setofSizeof());
1073   execute(setofReplace());
1074   execute(setofSubstr());
1075   execute(setofIsvalue());
1076   execute(setofIsvalue2());
1077   execute(setofIsbound());
1078
1079
1080   execute(setofSubtypes());
1081
1082
1083 }
1084
1085 }