/******************************************************************************
 * 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
 *   Baranyi, Botond
 *   Delic, Adam
 *   Forstner, Matyas
 *   Kovacs, Ferenc
 *   Raduly, Csaba
 *   Szabados, Kristof
 *   Szabo, Janos Zoltan – initial implementation
 *
 ******************************************************************************/
module TtemplateRecof {
type component mycomp {};
type record of integer templateRecof_myrecof;
type record templateRecof_rec {
 templateRecof_myrecof x1,
 templateRecof_myrecof x2,
 templateRecof_myrecof x3 optional };
template templateRecof_rec templateRecof_tSpec :={ //specific values
 x1:={1,1},
 x2:={2,1},
 x3:={3,1} };
template templateRecof_rec templateRecof_tList :={ //specific value and value list
 x1:={1,1},
 x2:=({2,1},{3,1},{6,1}),
 x3:={3,1} };
template templateRecof_rec templateRecof_tComp :={ //specific value and compl. list
 x1:={1,1},
 x2:=complement ({2,1},{3,1},{6,1}),
 x3:={3,1} };
template templateRecof_rec templateRecof_tOmit :={ //omitting values
 x1:={1,1},
 x2:={2,1},
 x3:=omit } ;
template templateRecof_rec templateRecof_tAny :={ //specific and any value
 x1:={1,1},
 x2:={2,1},
 x3:=? } ;
template templateRecof_rec templateRecof_tAnyorNone :={ //specific and AnyorNone value
 x1:={1,1},
 x2:={2,1},
 x3:=* };
template templateRecof_rec templateRecof_tLength1 :={ //specific value and length (fix)
 x1:={1,1},
 x2:={2,1},
 x3:=* length(3) };
template templateRecof_rec templateRecof_tLength2 :={ //specific value and length (range)
 x1:={1,1},
 x2:={2,1},
 x3:=? length(2..4) };
template templateRecof_rec templateRecof_tLength3 :={ //specific value and length (range, infinity)
 x1:={1,1},
 x2:={2,1},
 x3:=? length(2..infinity) };
template templateRecof_rec templateRecof_tIfpresent :={ // specific value and ifpresent
 x1:={1,1},
 x2:={2,1},
 x3:={3,1} ifpresent };
template templateRecof_rec templateRecof_tLengthIfp :={ //specific value and length (fix), ifpresent
 x1:={1,1},
 x2:={2,1},
 x3:=? length(3) ifpresent};
template templateRecof_rec templateRecof_tAnyEl :={ //specific value and any element inside value
 x1:={1,1},
 x2:={2,1},
 x3:={3,?,1} } ;
template templateRecof_rec templateRecof_tAnyorNoneEl :={ //specific value and Any number of elements or none inside value
 x1:={1,1},
 x2:={2,1},
 x3:={3,*,1} };

template templateRecof_rec aliased_template := templateRecof_tAnyorNoneEl;

testcase templateRecofSpec() runs on mycomp {
var templateRecof_myrecof temp:={3,1};
var templateRecof_rec x1,x2;		//specific value
x1:={ x1:={1,1},  x2:={2,1},  x3:=temp };
x2:={ x1:={2,1},  x2:={2,1},  x3:=temp };
//match
if (match(x1,templateRecof_tSpec)) {setverdict(pass);}
 else {setverdict(fail);}
//no match
if (not(match(x2,templateRecof_tSpec))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofList() runs on mycomp {
var templateRecof_myrecof temp:={3,1};
var templateRecof_rec x1,x2,x3;		//value list
x1:={ x1:={1,1},  x2:={6,1},  x3:=temp };
x2:={ x1:={1,1},  x2:={7,1},  x3:=temp };
x3:={ x1:={8,1},  x2:={6,1},  x3:=temp };
//match
if (match(x1,templateRecof_tList)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of list
if (not(match(x2,templateRecof_tList))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateRecof_tList))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofComp() runs on mycomp {
var templateRecof_myrecof temp:={3,1};
var templateRecof_rec x1,x2,x3;		//complemented list
x1:={ x1:={1,1},  x2:={7,1},  x3:=temp };
x2:={ x1:={1,1},  x2:={6,1},  x3:=temp };
x3:={ x1:={2,1},  x2:={7,1},  x3:=temp };
//match
if (match(x1,templateRecof_tComp)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: in the list
if (not(match(x2,templateRecof_tComp))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateRecof_tComp))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofOmit() runs on mycomp {
var templateRecof_myrecof temp:={3,1};
var templateRecof_rec x1,x2,x3;		//omitting value
x1:={ x1:={1,1},  x2:={2,1},  x3:=omit };
x2:={ x1:={1,1},  x2:={2,1},  x3:=temp };
x3:={ x1:={2,1},  x2:={2,1},  x3:=omit };
//match
if (match(x1,templateRecof_tOmit)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: not omitted
if (not(match(x2,templateRecof_tOmit))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateRecof_tOmit))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofAny() runs on mycomp {
var templateRecof_myrecof temp:={3,1};
var templateRecof_rec x1,x2,x3;		//any value
x1:={ x1:={1,1},  x2:={2,1},  x3:=temp };
x2:={ x1:={1,1},  x2:={2,1},  x3:=omit };
x3:={ x1:={2,1},  x2:={2,1},  x3:=temp };
//match
if (match(x1,templateRecof_tAny)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: field omitted
if (not(match(x2,templateRecof_tAny))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateRecof_tAny))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofAnyorNone() runs on mycomp {
var templateRecof_myrecof temp:={3,1};
var templateRecof_rec x1,x2,x3;		//AnyorNone value
x1:={ x1:={1,1},  x2:={2,1},  x3:=omit };
x2:={ x1:={1,1},  x2:={2,1},  x3:=temp };
x3:={ x1:={2,1},  x2:={2,1},  x3:=omit };
//match: omitted
if (match(x1,templateRecof_tAnyorNone)) {setverdict(pass);}
 else {setverdict(fail);}
//match: value
if (match(x2,templateRecof_tAnyorNone)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateRecof_tAnyorNone))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofLength1() runs on mycomp {
var templateRecof_myrecof temp1:={1,2,3};	//length (fix)
var templateRecof_myrecof temp2:={1,2};
var templateRecof_rec x1,x2,x3,x4;
x1:={ x1:={1,1},  x2:={2,1},  x3:=temp1 };
x2:={ x1:={1,1},  x2:={2,1},  x3:=omit };
x3:={ x1:={1,1},  x2:={2,1},  x3:=temp2 };
x4:={ x1:={1,1,1},  x2:={2,1},  x3:=temp1 };
//match: proper length
if (match(x1,templateRecof_tLength1)) {setverdict(pass);}
 else {setverdict(fail);}
//match: omitted
if (match(x2,templateRecof_tLength1)) {setverdict(pass);}
 else {setverdict(fail);}
// no match: not proper length
if (not(match(x3,templateRecof_tLength1))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x4,templateRecof_tLength1))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofLength2() runs on mycomp {
var templateRecof_myrecof temp1:={1,2};	// length (range)
var templateRecof_myrecof temp2:={1};
var templateRecof_rec x1,x2,x3;
x1:={ x1:={1,1},  x2:={2,1},  x3:=temp1 };
x2:={ x1:={1,1},  x2:={2,1},  x3:=temp2 };
x3:={ x1:={1},  x2:={2,1},  x3:=temp1 };
//match
if (match(x1,templateRecof_tLength2)) {setverdict(pass);}
 else {setverdict(fail);}
// no match: not proper length
if (not(match(x2,templateRecof_tLength2))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateRecof_tLength2))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofLength3() runs on mycomp {
var templateRecof_myrecof temp1:={1,2};	// length (range, infinity)
var templateRecof_myrecof temp2:={1};
var templateRecof_rec x1,x2,x3;
x1:={ x1:={1,1},  x2:={2,1},  x3:=temp1 };
x2:={ x1:={1,1},  x2:={2,1},  x3:=temp2 };
x3:={ x1:={1},  x2:={2,1},  x3:=temp1 };
//match
if (match(x1,templateRecof_tLength3)) {setverdict(pass);}
 else {setverdict(fail);}
// no match: not proper length
if (not(match(x2,templateRecof_tLength3))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateRecof_tLength3))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofIfpresent() runs on mycomp {
var templateRecof_myrecof temp1:={3,1};       //ifpresent
var templateRecof_myrecof temp2:={4,1};
var templateRecof_rec x1,x2,x3,x4;
x1:={ x1:={1,1},  x2:={2,1},  x3:=temp1 };
x2:={ x1:={1,1},  x2:={2,1},  x3:=omit };
x3:={ x1:={1,1},  x2:={2,1},  x3:=temp2 };
x4:={ x1:={2,1},  x2:={2,1},  x3:=omit };
//match: present and match
if (match(x1,templateRecof_tIfpresent)) {setverdict(pass);}
 else {setverdict(fail);}
//match: not present
if (match(x2,templateRecof_tIfpresent)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: present and not match
if (not(match(x3,templateRecof_tIfpresent))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x4,templateRecof_tIfpresent))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofLengthIfp() runs on mycomp {
var templateRecof_myrecof temp1:={1,2,3};     //length (fix), ifpresent
var templateRecof_myrecof temp2:={1,2};
var templateRecof_rec x1,x2,x3,x4;
x1:={ x1:={1,1},  x2:={2,1},  x3:=temp1 };
x2:={ x1:={1,1},  x2:={2,1},  x3:=omit };
x3:={ x1:={1,1},  x2:={2,1},  x3:=temp2 };
x4:={ x1:={1,1,1},  x2:={2,1},  x3:=temp1 };
//match: proper length
if (match(x1,templateRecof_tLengthIfp)) {setverdict(pass);}
 else {setverdict(fail);}
//match: omitted
if (match(x2,templateRecof_tLengthIfp)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: not proper length
if (not(match(x3,templateRecof_tLengthIfp))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x4,templateRecof_tLengthIfp))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofAnyEl() runs on mycomp {
var templateRecof_myrecof temp1:={3,15,1};    // any element
var templateRecof_myrecof temp2:={3,1};
var templateRecof_myrecof temp3:={3,1,4,1};
var templateRecof_myrecof temp4:={3,1,2};
var templateRecof_rec x1,x2,x3,x4,x5;
x1:={ x1:={1,1},  x2:={2,1},  x3:=temp1 };
x2:={ x1:={1,1},  x2:={2,1},  x3:=temp2 };
x3:={ x1:={1,1},  x2:={2,1},  x3:=temp3 };
x4:={ x1:={1,1},  x2:={2,1},  x3:=temp4 };
x5:={ x1:={1},  x2:={2,1},  x3:=temp1 };
//match
if (match(x1,templateRecof_tAnyEl)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: no element
if (not(match(x2,templateRecof_tAnyEl))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: two element
if (not(match(x3,templateRecof_tAnyEl))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: wrong element
if (not(match(x4,templateRecof_tAnyEl))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x5,templateRecof_tAnyEl))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateRecofAnyorNoneEl() runs on mycomp {
var templateRecof_myrecof temp1:={3,1};       //Any number of elements or none
var templateRecof_myrecof temp2:={3,5,1};
var templateRecof_myrecof temp3:={3,2,5,1};
var templateRecof_myrecof temp4:={4,2,1};
var templateRecof_myrecof temp5:={3,5,1,2,1};
var templateRecof_myrecof temp6:={3,5,1,2};
var templateRecof_rec x1,x2,x3,x4,x5,x6,x7;
x1:={ x1:={1,1},  x2:={2,1},  x3:=temp1 };
x2:={ x1:={1,1},  x2:={2,1},  x3:=temp2 };
x3:={ x1:={1,1},  x2:={2,1},  x3:=temp3 };
x4:={ x1:={1,1},  x2:={2,1},  x3:=temp4 };
x5:={ x1:={1,2},  x2:={2,1},  x3:=temp3 };
x6:={ x1:={1,1},  x2:={2,1},  x3:=temp5 };
x7:={ x1:={1,1},  x2:={2,1},  x3:=temp6 };
//match: no element
if (match(x1,templateRecof_tAnyorNoneEl)) {setverdict(pass);}
 else {setverdict(fail);}
//match: one element
if (match(x2,templateRecof_tAnyorNoneEl)) {setverdict(pass);}
 else {setverdict(fail);}
//match: two element
if (match(x3,templateRecof_tAnyorNoneEl)) {setverdict(pass);}
 else {setverdict(fail);}
//see if the algorithm goes till the end
if (match(x6,templateRecof_tAnyorNoneEl)) {setverdict(pass);}
 else {setverdict(fail);}
  //no match: other element
if (not(match(x4,templateRecof_tAnyorNoneEl))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x5,templateRecof_tAnyorNoneEl))) {setverdict(pass);}
 else {setverdict(fail);}
//see if the algorithm goes till the end
if (not(match(x7,templateRecof_tAnyorNoneEl))) {setverdict(pass);}
 else {setverdict(fail);}
}

 testcase templateRecofPermutation() runs on mycomp {
   template templateRecof_rec t1 := {
     {1,1},
     {permutation(1,2,3)},
     {3,1}
   };
   template templateRecof_rec t2 := {
     {1,1},
     {permutation(1,2,3), 4},
     {3,1}
   };
   template templateRecof_rec t3 := {
     {1,1},
     {permutation(1,2,3,*), 4},
     {3,1}
   };
   template templateRecof_rec t4 := {
     {1,1},
     {permutation(1,2,?,*), 4},
     {3,1}
   };
   template templateRecof_rec t5 := {
     {1,1},
     {permutation(1,2,?), 4},
     {3,1}
   };
   template templateRecof_rec t6 := {
     {1,1},
     {permutation(1,2,?,?), 4},
     {3,1}
   };
   template templateRecof_rec t7 := {
     {1,1},
     {permutation(?,1,2,?), 4},
     {3,1}
   };
   template templateRecof_rec t8 := {
     {1,1},
     {permutation(8,1,2,?), 4},
     {3,1}
   };
   template templateRecof_rec t9 := {
     {1,1},
     {permutation(1,*,2,3,*), 4},
     {3,1}
   };
   template templateRecof_rec t10 := {
     {1,1},
     {*, permutation(2,3,*), *},
     {3,1}
   };
   template templateRecof_rec t11 := {
     {1,1},
     {*, permutation(2,3), *},
     {3,1}
   };
   template templateRecof_rec t12 := {
     {1,1},
     {*, permutation(2,3,*), *, 4},
     {3,1}
   };
   template templateRecof_rec t13 := {
     {1,1},
     {*, permutation(2,3,*), *, 4, *},
     {3,1}
   };
   template templateRecof_rec t14 := {
     {1,1},
     {*, permutation(2,?), *, 4, *},
     {3,1}
   };
   template templateRecof_rec t15 := {
     {1,1},
     {*, permutation(2,?), ?, 4, *},
     {3,1}
   };
   template templateRecof_rec t16 := {
     {1,1},
     {1, *, permutation(3,?), ?, 4, *},
     {3,1}
   };
   template templateRecof_rec t17 := {
     {1,1},
     {1, *, permutation(3,?), ?, *},
     {3,1}
   };
   template templateRecof_rec t18 := {
     {1,1},
     {permutation(3,?), permutation(4, *)},
     {3,1}
   };
   template templateRecof_rec t19 := {
     {1,1},
     {?, permutation(3,?), permutation(4, *)},
     {3,1}
   };
   template templateRecof_rec t20 := {
     {1,1},
     {permutation(2,1), permutation(4,3)},
     {3,1}
   };
   var templateRecof_rec v1 := {x1:={1,1}, x2:={1,2,3}, x3:={3,1}};
   var templateRecof_rec v2 := {x1:={1,1}, x2:={2,3,1}, x3:={3,1}};
   var templateRecof_rec v3 := {x1:={1,1}, x2:={1,2,3,4}, x3:={3,1}};

   if(match(v1,t1)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v2,t1)) {setverdict(pass);} else {setverdict(fail);}
   if(not match(v3,t1)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t2)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t3)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t4)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t5)) {setverdict(pass);} else {setverdict(fail);}
   if(not match(v3,t6)) {setverdict(pass);} else {setverdict(fail);}
   if(not match(v3,t7)) {setverdict(pass);} else {setverdict(fail);}
   if(not match(v3,t8)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t9)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t10)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t11)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t12)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t13)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t14)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t15)) {setverdict(pass);} else {setverdict(fail);}
   if(not match(v3,t16)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t17)) {setverdict(pass);} else {setverdict(fail);}
   if(not match(v3,t18)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t19)) {setverdict(pass);} else {setverdict(fail);}
   if(match(v3,t20)) {setverdict(pass);} else {setverdict(fail);}
 }

 type record r_A { charstring f1 }
 type record of r_A ro_B
 testcase HK38721() runs on mycomp {
   var ro_B v_B := { { "" } }
   // 3.0.4 was unable to compile the generated code for this.
   log(match("", v_B[0].f1))
   setverdict(pass)
 }

testcase templateRecofIsvalue() runs on mycomp {
  var template templateRecof_myrecof tpl1;
  var template templateRecof_myrecof tpl2 := { 0,1,2,3,4,5,6,7,8,9 }
  template templateRecof_myrecof tpl3 := { *,?,*,?,*,?,*,?,*,? };
  template templateRecof_myrecof tpl4 := { (0,1,2,3),*,?,*,?,*,?,*,?,42 };

  if ( isvalue(tpl1) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(tpl2) ) { setverdict(pass); } else { setverdict(fail); }
  if ( isvalue(tpl3) ) { setverdict(fail); } else { setverdict(pass); };
  if ( isvalue(tpl4) ) { setverdict(fail); } else { setverdict(pass); };
}

type record of charstring ROC;
type record of integer  ROI;
type record MyRecord1 {
  integer       i optional,
  float         x optional,
  charstring    c
}

type union MyUnion1 {
  ROC roc,
  integer i,
  ROI roi,
  MyRecord1 r
}

type record MyRec2 {
  ROC roc optional,
  ROI roi optional,
  MyUnion1 u optional, 
  MyRecord1 r optional
}

type record of MyRec2 MyRecOf

template MyRecOf t_recOf1 := (
  { [0]:= { roc:=omit }, [1]:= {roc:=omit} },
  { [0]:= { roc:=omit }, [1]:= {roc:={"one", "two"}} },
  { [0]:= { roc:=omit }, [2]:= {u:={i:=5}} }
)

testcase tc_recordOf_template1() runs on mycomp {
  var template MyRecOf vtl_recOf:= t_recOf1;
  if(isbound( vtl_recOf )) {setverdict(pass)}else {setverdict(fail)};
  if(isbound( t_recOf1 )) {setverdict(pass)}else {setverdict(fail)};
}

testcase tc_recordOf_template2() runs on mycomp {
  var template MyRecOf vtl_recOf:= t_recOf1;
  if(isbound( vtl_recOf[0] )) {setverdict(fail)}else {setverdict(pass)};
  if(isbound( vtl_recOf[1] )) {setverdict(fail)}else {setverdict(pass)};
  if(isbound( vtl_recOf[2] )) {setverdict(fail)}else {setverdict(pass)}; 
} 

testcase tc_recordOf_template1_ispresent() runs on mycomp {
  var template MyRecOf vtl_recOf:= t_recOf1;
  if(ispresent( vtl_recOf )) {setverdict(pass)}else {setverdict(fail)};
  if(ispresent( t_recOf1 )) {setverdict(pass)}else {setverdict(fail)};
}

testcase tc_recordOf_template2_ispresent() runs on mycomp {
  var template MyRecOf vtl_recOf:= t_recOf1;
  if(ispresent( vtl_recOf[0] )) {setverdict(fail)}else {setverdict(pass)};
  if(ispresent( vtl_recOf[1] )) {setverdict(fail)}else {setverdict(pass)};
  if(ispresent( vtl_recOf[2] )) {setverdict(fail)}else {setverdict(pass)}; 
}

testcase tc_recordOf_template_unbound_elements_lengthof_sizeof() runs on mycomp {
  var ROI temp;
  var template ROI ttemp;
  temp[99] := 0;
  ttemp[99] := 0;
  if ((sizeof(temp)==100) and (sizeof(temp)==sizeof(ttemp))) { setverdict(pass); } else { setverdict(fail); }
  if ((lengthof(temp)==100) and (lengthof(temp)==lengthof(ttemp))) { setverdict(pass); } else { setverdict(fail); }
}

type record Block {}

type record of Block Blocks;

type record Request {
  Blocks blocks optional
}

testcase HO91743() runs on mycomp {
  var template Request vt_ReqO := { blocks := omit };
  var template Request vt_ReqQ := { blocks := ? };
  var template Request vt_ReqS := { blocks := * };
  var template Block vt_b := {}

  vt_ReqQ.blocks[3] := vt_b;
  vt_ReqS.blocks[3] := vt_b;
  // Indexing a template record-of which was omit used to DTE
  // (in contrast to any-value and any-or-omit, which would create the record-of).
  // HO91743 unifies the behaviour (record-of is created when indexing omit).
  vt_ReqO.blocks[3] := vt_b;

  if (lengthof(vt_ReqO.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
  if (sizeof  (vt_ReqO.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }

  if (lengthof(vt_ReqQ.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
  if (sizeof  (vt_ReqQ.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }

  if (lengthof(vt_ReqS.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
  if (sizeof  (vt_ReqS.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
}

//=================================================================
// isbound tests for ROI
function f_isbound4ROI_getLen(template ROI pl_roi) return integer {
  var integer i := 0;
  while(isbound(pl_roi[i])){
    i:=i+1;
  }
  return i; 
}

template ROI t_il0:={};
template ROI t_il1:={0};
template ROI t_il2:={0,*};
template ROI t_il3:={0,?};
template ROI t_il4:={0,1,2,3,?};

function f(template ROI roi,integer expected){
  var integer index:= f_isbound4ROI_getLen(roi);
  if(index==expected) {
    setverdict(pass,"Result:", index);
  }else {
    setverdict(fail,"Result:",index," expected:", expected);
  } 
}

testcase tc_isbound4ROI0() runs on mycomp {
  f(t_il0,0);
}

testcase tc_isbound4ROI1() runs on mycomp {
  f(t_il1,1);
}

testcase tc_isbound4ROI2() runs on mycomp {
  f(t_il2,2);
}

testcase tc_isbound4ROI3() runs on mycomp {
  f(t_il3,2);
}

testcase tc_isbound4ROI4() runs on mycomp {
  f(t_il4,5);
}

template integer tpard(template integer i) := i;

testcase tc_HU56425() runs on mycomp {
  template integer t_i := tpard(3);
  template templateRecof_myrecof t_list := { tpard(t_i) };
  // HU56425 refers to a code generation error (which caused a C++ compilation error), but let's check the resulting template anyway
  template templateRecof_myrecof t_list_exp := { 3 };
  if (log2str(t_list) == log2str(t_list_exp)) { setverdict(pass); }
  else { setverdict(fail); }
}


control {
 execute(templateRecofSpec());
 execute(templateRecofList());
 execute(templateRecofComp());
 execute(templateRecofOmit());
 execute(templateRecofAny());
 execute(templateRecofAnyorNone());
 execute(templateRecofLength1());
 execute(templateRecofLength2());
 execute(templateRecofLength3());
 execute(templateRecofIfpresent());
 execute(templateRecofLengthIfp());
 execute(templateRecofAnyEl());
 execute(templateRecofAnyorNoneEl());
 execute(templateRecofPermutation());
 execute(HK38721());
 execute(templateRecofIsvalue());
 
 execute(tc_recordOf_template1());
 execute(tc_recordOf_template2());
 execute(tc_recordOf_template1_ispresent());
 execute(tc_recordOf_template2_ispresent());

 execute(tc_recordOf_template_unbound_elements_lengthof_sizeof());
 execute(HO91743());
 execute(tc_isbound4ROI0());
 execute(tc_isbound4ROI1());
 execute(tc_isbound4ROI2());
 execute(tc_isbound4ROI3());
 execute(tc_isbound4ROI4());

}
}