regression_test/predefFunction/size_of_OK.ttcn

   1 /******************************************************************************
   2  * Copyright (c) 2000-2015 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 size_of_OK {     //^In TTCN-3 module `size_of_OK'://
   9
  10 type component PDTestComponent {};
  11
  12 /*--- SIZEOF ON RECORDOF  --------------------------------------------------*/
  13
  14 type record of integer sirortype1
  15 type record of sirortype1 sirortype2
  16
  17 const sirortype1 siro1 := {}
  18 const sirortype1 siro2 := {1}
  19 const sirortype1 siro3 := {1,2}
  20
  21 const sirortype2 siro4 := {{}}
  22 const sirortype2 siro5 := {{},{}}
  23 const sirortype2 siro6 := {{1},{1,2}}
  24
  25 modulepar integer sirocon1 := sizeof(siro1)
  26 modulepar integer sirocon2 := sizeof(siro2)
  27 modulepar integer sirocon3 := sizeof(siro3)
  28
  29 modulepar integer sirocon4 := sizeof(siro4)
  30 modulepar integer sirocon5 := sizeof(siro5)
  31 modulepar integer sirocon6 := sizeof(siro5[1])
  32 modulepar integer sirocon7 := sizeof(siro6[1])
  33
  34
  35 testcase sizeof_recof() runs on PDTestComponent{
  36
  37         if ((sirocon1 == 0)
  38         and (sirocon1 == sizeof(siro1)))
  39              {setverdict(pass);}
  40         else {setverdict(fail);}
  41         if ((sirocon2 == 1)
  42         and (sirocon2 == sizeof(siro2)))
  43              {setverdict(pass);}
  44         else {setverdict(fail);}
  45         if ((sirocon3 == 2)
  46         and (sirocon3 == sizeof(siro3)))
  47              {setverdict(pass);}
  48         else {setverdict(fail);}
  49         if ((sirocon4 == 1)
  50         and (sirocon4 == sizeof(siro4)))
  51              {setverdict(pass);}
  52         else {setverdict(fail);}
  53         if ((sirocon5 == 2)
  54         and (sirocon5 == sizeof(siro5)))
  55              {setverdict(pass);}
  56         else {setverdict(fail);}
  57         if ((sirocon6 == 0)
  58         and (sirocon6 == sizeof(siro5[1])))
  59              {setverdict(pass);}
  60         else {setverdict(fail);}
  61         if ((sirocon7 == 2)
  62         and (sirocon7 == sizeof(siro6[1])))
  63              {setverdict(pass);}
  64         else {setverdict(fail);}
  65
  66         var template sirortype1 tr_sirortype1 := {1, 2, 3}
  67         if (sizeof(tr_sirortype1) == 3) {
  68                 setverdict(pass);
  69         } else {
  70                 setverdict(fail);
  71         }
  72
  73 }
  74
  75
  76 /*--- SIZEOF ON SETOF  --------------------------------------------------*/
  77
  78 type set of integer sisostype1
  79 type set of sisostype1 sisostype2
  80
  81 const sisostype1 siso1 := {}
  82 const sisostype1 siso2 := {1}
  83 const sisostype1 siso3 := {1,2}
  84 const sisostype2 siso4 := {{}}
  85 const sisostype2 siso5 := {{},{}}
  86 const sisostype2 siso6 := {{1},{1,2}}
  87
  88 modulepar integer sisocon1 := sizeof(siso1)
  89 modulepar integer sisocon2 := sizeof(siso2)
  90 modulepar integer sisocon3 := sizeof(siso3)
  91
  92 modulepar integer sisocon4 := sizeof(siso4)
  93 modulepar integer sisocon5 := sizeof(siso5)
  94 modulepar integer sisocon6 := sizeof(siso5[1])
  95 modulepar integer sisocon7 := sizeof(siso6[1])
  96
  97
  98 testcase sizeof_setof() runs on PDTestComponent{ //In testcase definition//
  99
 100         if ((sisocon1 == 0)
 101         and (sisocon1 == sizeof(siso1)))
 102              {setverdict(pass);}
 103         else {setverdict(fail);}
 104         if ((sisocon2 == 1)
 105         and (sisocon2 == sizeof(siso2)))
 106              {setverdict(pass);}
 107         else {setverdict(fail);}
 108         if ((sisocon3 == 2)
 109         and (sisocon3 == sizeof(siso3)))
 110              {setverdict(pass);}
 111         else {setverdict(fail);}
 112         if ((sisocon4 == 1)
 113         and (sisocon4 == sizeof(siso4)))
 114              {setverdict(pass);}
 115         else {setverdict(fail);}
 116         if ((sisocon5 == 2)
 117         and (sisocon5 == sizeof(siso5)))
 118              {setverdict(pass);}
 119         else {setverdict(fail);}
 120         if ((sisocon6 == 0)
 121         and (sisocon6 == sizeof(siso5[1])))
 122              {setverdict(pass);}
 123         else {setverdict(fail);}
 124         if ((sisocon7 == 2)
 125         and (sisocon7 == sizeof(siso6[1])))
 126              {setverdict(pass);}
 127         else {setverdict(fail);}
 128
 129   var template sisostype1 sisot1 := subset( 1, 2 , 3) length (3..10);
 130   var template sisostype1 sisot2 := superset( 1, 2 , 3) length (1..3);
 131   var template sisostype1 sisot3 := subset( 1, * , 3) length (1000); //In template variable definition// \
 132     //In element 2 of subset//   //warning: `\*' in subset\. This template will match everything//
 133   if (sizeof(sisot1)==3)
 134              {setverdict(pass);}
 135         else {setverdict(fail);}
 136   if (sizeof(sisot2)==3)
 137              {setverdict(pass);}
 138         else {setverdict(fail);}
 139   if (sizeof(sisot3)==1000)
 140              {setverdict(pass);}
 141         else {setverdict(fail);}
 142 }
 143
 144 /*--- SIZEOF ON ARRAY  --------------------------------------------------*/
 145
 146 type record of integer siarrtype
 147
 148 const siarrtype siar1[1] := {{}}
 149 const siarrtype siar2[1] := {{1}}
 150 const siarrtype siar3[3] := {{},{1},{1,2}}
 151
 152
 153 modulepar integer siarcon1 := sizeof(siar1)
 154 modulepar integer siarcon2 := sizeof(siar2)
 155 modulepar integer siarcon3 := sizeof(siar3)
 156
 157 testcase sizeof_array() runs on PDTestComponent{
 158
 159         if ((siarcon1 == 1)
 160         and (siarcon1 == sizeof(siar1)))
 161              {setverdict(pass);}
 162         else {setverdict(fail);}
 163         if ((siarcon2 == 1)
 164         and (siarcon2 == sizeof(siar2)))
 165              {setverdict(pass);}
 166         else {setverdict(fail);}
 167         if ((siarcon3 == 3)
 168         and (siarcon3 == sizeof(siar3)))
 169              {setverdict(pass);}
 170         else {setverdict(fail);}
 171
 172 }
 173
 174 control {
 175         execute (sizeof_recof());
 176         execute (sizeof_setof());
 177         execute (sizeof_array());
 178 }
 179
 180 }