regression_test/XML/XER/Txernested.ttcnpp

   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 Txernested
   9 {
  10 modulepar boolean Txernested_verbose := false;
  11 #define verbose Txernested_verbose
  12 #include "../macros.ttcnin"
  13
  14 external function flatten(inout universal charstring par) ;
  15
  16 import from Asntypes all;
  17 import from AsnValues all;
  18
  19 type set of record {
  20   set {
  21     integer ts1,
  22     boolean ts2
  23   } f1 optional,
  24   deep f2
  25 } nestor; // TTCNv3 equivalent of Nestor
  26
  27 //   SEQ    OF SET OF SEQ    OF SET OF SEQUENCE {
  28 type record of set of record of set of record  {
  29   //   your CHOICE { only REAL } OPTIONAL
  30   union { float only } your optional
  31 } deep
  32
  33 /*
  34   type record nested_inner {
  35     set {
  36       integer ts1,
  37       boolean ts2
  38     } f1 optional,
  39     deep f2
  40   } ;
  41
  42   const nested_inner ni := {
  43     f1 := omit,
  44     f2 := {{{{}}}}
  45   }
  46
  47   const nested_inner eki_eki :=
  48   {
  49
  50       { ts1 := 17, ts2 := true }
  51     , {}
  52   }
  53   */
  54 const nestor n3 :=
  55 {
  56   { omit, {} },
  57   { omit, {{}} },
  58   { omit, {{{}}} }
  59 }
  60
  61 type component Tnested {}
  62
  63  DECLARE_XER_ENCODERS(nestor, nst);
  64 DECLARE_EXER_ENCODERS(nestor, nst)
  65  DECLARE_XER_ENCODERS(Nestor, Nst);
  66 DECLARE_EXER_ENCODERS(Nestor, Nst)
  67  DECLARE_XER_ENCODERS(NestorEx, Nstx);
  68 DECLARE_EXER_ENCODERS(NestorEx, Nstx)
  69
  70 //const charstring oftype := "oftype";
  71
  72 const deep d_empty := {{{{}}}}
  73 const Deep D_empty := {{{{}}}}
  74 const nestor  n_empty := {
  75 }
  76 const nestor n2 := {
  77   { omit, {} }
  78 }
  79 const charstring s_empty := "<nestor/>\n\n";
  80
  81 const charstring s_2 :=
  82 "<nestor>\n" &
  83 "\t<SEQUENCE>\n" &
  84 "\t\t<f2/>\n" &
  85 "\t</SEQUENCE>\n" &
  86 "</nestor>\n\n";
  87
  88 const charstring s_3 :=
  89 "<nestor>\n" &
  90
  91 "\t<SEQUENCE>\n" &
  92 "\t\t<f2/>\n" &
  93 "\t</SEQUENCE>\n" &
  94
  95 "\t<SEQUENCE>\n" &
  96 "\t\t<f2>\n" &
  97 "\t\t\t<SET_OF/>\n" &
  98 "\t\t</f2>\n" &
  99 "\t</SEQUENCE>\n" &
 100
 101 "\t<SEQUENCE>\n" &
 102 "\t\t<f2>\n" &
 103 "\t\t\t<SET_OF>\n" &
 104 "\t\t\t\t<SEQUENCE_OF/>\n" &
 105 "\t\t\t</SET_OF>\n" &
 106 "\t\t</f2>\n" &
 107 "\t</SEQUENCE>\n" &
 108
 109 "</nestor>\n\n";
 110
 111 /////////////////////////////////////////////////////////////////////
 112 testcase encode_nest() runs on Tnested {
 113   var universal charstring expected := s_empty;
 114   CHECK_METHOD(bxer_enc_nst, n_empty, expected);
 115   CHECK_METHOD(exer_enc_nst, n_empty, expected);
 116   flatten(expected);
 117   CHECK_METHOD(cxer_enc_nst, n_empty, expected & lf);
 118
 119   expected := s_2;
 120   CHECK_METHOD(bxer_enc_nst, n2, expected);
 121   CHECK_METHOD(exer_enc_nst, n2, expected);
 122   flatten(expected);
 123   CHECK_METHOD(cxer_enc_nst, n2, expected & lf);
 124
 125   expected := s_3;
 126   CHECK_METHOD(bxer_enc_nst, n3, expected);
 127   CHECK_METHOD(exer_enc_nst, n3, expected);
 128   flatten(expected);
 129   CHECK_METHOD(cxer_enc_nst, n3, expected & lf);
 130 }
 131
 132 testcase decode_nest() runs on Tnested {
 133   var nestor expected;
 134
 135   expected := n_empty;
 136   CHECK_DECODE2(nst, s_empty, nestor, expected);
 137
 138   expected := n2;
 139   CHECK_DECODE2(nst, s_2, nestor, expected);
 140
 141   expected := n3;
 142   CHECK_DECODE2(nst, s_3, nestor, expected);
 143 }
 144
 145 /////////////////////////////////////////////////////////////////////
 146
 147 const charstring nstr_nixtor :=
 148 "<Nestor>\n" &
 149 "\t<SEQUENCE>\n" &
 150 "\t\t<name>nixtor</name>\n" &
 151 "\t\t<f2/>\n" &
 152 "\t</SEQUENCE>\n" &
 153 "</Nestor>\n\n";
 154
 155 const charstring nstr_nixtor2 :=
 156 "<Nestor>\n" &
 157 "\t<SEQUENCE>\n" &
 158 "\t\t<name>nixtor2</name>\n" &
 159 "\t\t<f2>\n" &
 160 "\t\t\t<SET_OF/>\n" &
 161 "\t\t</f2>\n" &
 162 "\t</SEQUENCE>\n" &
 163 "</Nestor>\n\n";
 164
 165 const charstring nstr_nixtor3 :=
 166 "<Nestor>\n" &
 167 "\t<SEQUENCE>\n" &
 168 "\t\t<name>nixtor3</name>\n" &
 169 "\t\t<f2>\n" &
 170 "\t\t\t<SET_OF>\n" &
 171 "\t\t\t\t<SEQUENCE_OF/>\n" &
 172 "\t\t\t</SET_OF>\n" &
 173 "\t\t</f2>\n" &
 174 "\t</SEQUENCE>\n" &
 175 "</Nestor>\n\n";
 176
 177 const charstring nstr_nixtor4 :=
 178 "<Nestor>\n" &
 179 "\t<SEQUENCE>\n" &
 180 "\t\t<name>nixtor4</name>\n" &
 181 "\t\t<f2>\n" &
 182 "\t\t\t<SET_OF>\n" &
 183 "\t\t\t\t<SEQUENCE_OF/>\n" &
 184 "\t\t\t</SET_OF>\n" &
 185 "\t\t</f2>\n" &
 186 "\t</SEQUENCE>\n" &
 187 "</Nestor>\n\n";
 188
 189 const charstring nstr_an3 :=
 190 "<Nestor>\n" &
 191 "\t<SEQUENCE>\n" &
 192 "\t\t<name>an3[0]</name>\n" &
 193 "\t\t<f2/>\n" &
 194 "\t</SEQUENCE>\n" &
 195 "\t<SEQUENCE>\n" &
 196 "\t\t<name>an3[1]</name>\n" &
 197 "\t\t<f2>\n" &
 198 "\t\t\t<SET_OF/>\n" &
 199 "\t\t</f2>\n" &
 200 "\t</SEQUENCE>\n" &
 201 "\t<SEQUENCE>\n" &
 202 "\t\t<name>an3[2]</name>\n" &
 203 "\t\t<f2>\n" &
 204 "\t\t\t<SET_OF>\n" &
 205 "\t\t\t\t<SEQUENCE_OF/>\n" &
 206 "\t\t\t</SET_OF>\n" &
 207 "\t\t</f2>\n" &
 208 "\t</SEQUENCE>\n" &
 209 "</Nestor>\n\n";
 210
 211 const charstring nstr_nn :=
 212 "<Nestor>\n" &
 213 "\t<SEQUENCE>\n" &
 214 "\t\t<name>nn</name>\n" &
 215 "\t\t<f1>\n" &
 216 "\t\t\t<ts1>10</ts1>\n" &
 217 "\t\t\t<ts2><true/></ts2>\n" &
 218 "\t\t</f1>\n" &
 219 "\t\t<f2>\n" &
 220 "\t\t\t<SET_OF>\n" &
 221 "\t\t\t\t<SEQUENCE_OF>\n" &
 222 "\t\t\t\t\t<SET_OF>\n" &
 223 "\t\t\t\t\t\t<SEQUENCE>\n" &
 224 "\t\t\t\t\t\t\t<your>\n" &
 225 "\t\t\t\t\t\t\t\t<only>5.000000</only>\n" &
 226 "\t\t\t\t\t\t\t</your>\n" &
 227 "\t\t\t\t\t\t</SEQUENCE>\n" &
 228 "\t\t\t\t\t</SET_OF>\n" &
 229 "\t\t\t\t</SEQUENCE_OF>\n" &
 230 "\t\t\t</SET_OF>\n" &
 231 "\t\t</f2>\n" &
 232 "\t</SEQUENCE>\n" &
 233 "</Nestor>\n\n";
 234
 235 const charstring nstrx_nixtorex :=
 236 "<NestorEx>\n" &
 237 "\t<NestorSeq>\n" &
 238 "\t\t<name>nixtorex</name>\n" &
 239 "\t\t<f2/>\n" &
 240 "\t</NestorSeq>\n" &
 241 "</NestorEx>\n\n";
 242
 243 const charstring nstrx_nixtor2ex :=
 244 "<NestorEx>\n" &
 245 "\t<NestorSeq>\n" &
 246 "\t\t<name>nixtor2ex</name>\n" &
 247 "\t\t<f2>\n" &
 248 "\t\t\t<Deep4o/>\n" &
 249 "\t\t</f2>\n" &
 250 "\t</NestorSeq>\n" &
 251 "</NestorEx>\n\n";
 252
 253 const charstring nstrx_nixtor3ex :=
 254 "<NestorEx>\n" &
 255 "\t<NestorSeq>\n" &
 256 "\t\t<name>nixtor3ex</name>\n" &
 257 "\t\t<f2>\n" &
 258 "\t\t\t<Deep4o>\n" &
 259 "\t\t\t\t<Deep3o/>\n" &
 260 "\t\t\t</Deep4o>\n" &
 261 "\t\t</f2>\n" &
 262 "\t</NestorSeq>\n" &
 263 "</NestorEx>\n\n";
 264
 265 const charstring nstrx_nixtor4ex :=
 266 "<NestorEx>\n" &
 267 "\t<NestorSeq>\n" &
 268 "\t\t<name>nixtor4ex</name>\n" &
 269 "\t\t<f2>\n" &
 270 "\t\t\t<Deep4o>\n" &
 271 "\t\t\t\t<Deep3o/>\n" &
 272 "\t\t\t</Deep4o>\n" &
 273 "\t\t</f2>\n" &
 274 "\t</NestorSeq>\n" &
 275 "</NestorEx>\n\n";
 276
 277 const charstring nstrx_an3ex :=
 278 "<NestorEx>\n" &
 279 "\t<NestorSeq>\n" &
 280 "\t\t<name>an3ex[0]</name>\n" &
 281 "\t\t<f2/>\n" &
 282 "\t</NestorSeq>\n" &
 283 "\t<NestorSeq>\n" &
 284 "\t\t<name>an3ex[1]</name>\n" &
 285 "\t\t<f2>\n" &
 286 "\t\t\t<Deep4o/>\n" &
 287 "\t\t</f2>\n" &
 288 "\t</NestorSeq>\n" &
 289 "\t<NestorSeq>\n" &
 290 "\t\t<name>an3ex[2]</name>\n" &
 291 "\t\t<f2>\n" &
 292 "\t\t\t<Deep4o>\n" &
 293 "\t\t\t\t<Deep3o/>\n" &
 294 "\t\t\t</Deep4o>\n" &
 295 "\t\t</f2>\n" &
 296 "\t</NestorSeq>\n" &
 297 "</NestorEx>\n\n";
 298
 299 const charstring nstrx_nnx :=
 300 "<NestorEx>\n" &
 301 "\t<NestorSeq>\n" &
 302 "\t\t<name>nnx</name>\n" &
 303 "\t\t<f1>\n" &
 304 "\t\t\t<ts1>10</ts1>\n" &
 305 "\t\t\t<ts2><true/></ts2>\n" &
 306 "\t\t</f1>\n" &
 307 "\t\t<f2>\n" &
 308 "\t\t\t<Deep4o>\n" &
 309 "\t\t\t\t<Deep3o>\n" &
 310 "\t\t\t\t\t<Deep2o>\n" &
 311 "\t\t\t\t\t\t<Deep1s>\n" &
 312 "\t\t\t\t\t\t\t<your>\n" &
 313 "\t\t\t\t\t\t\t\t<only>5.000000</only>\n" &
 314 "\t\t\t\t\t\t\t</your>\n" &
 315 "\t\t\t\t\t\t</Deep1s>\n" &
 316 "\t\t\t\t\t</Deep2o>\n" &
 317 "\t\t\t\t</Deep3o>\n" &
 318 "\t\t\t</Deep4o>\n" &
 319 "\t\t</f2>\n" &
 320 "\t</NestorSeq>\n" &
 321 "</NestorEx>\n\n";
 322
 323 testcase encode_nest_asn() runs on Tnested
 324 {
 325   var universal charstring expected;
 326
 327   expected := nstr_nixtor;
 328   CHECK_METHOD(bxer_enc_Nst, AsnValues.nixtor, expected);
 329   flatten(expected);
 330   CHECK_METHOD(cxer_enc_Nst, AsnValues.nixtor, expected & lf);
 331
 332   expected := nstr_nixtor2;
 333   CHECK_METHOD(bxer_enc_Nst, AsnValues.nixtor2, expected);
 334   flatten(expected);
 335   CHECK_METHOD(cxer_enc_Nst, AsnValues.nixtor2, expected & lf);
 336
 337   expected := nstr_nixtor3;
 338   CHECK_METHOD(bxer_enc_Nst, AsnValues.nixtor3, expected);
 339   flatten(expected);
 340   CHECK_METHOD(cxer_enc_Nst, AsnValues.nixtor3, expected & lf);
 341
 342   expected := nstr_nixtor4;
 343   CHECK_METHOD(bxer_enc_Nst, AsnValues.nixtor4, expected);
 344   flatten(expected);
 345   CHECK_METHOD(cxer_enc_Nst, AsnValues.nixtor4, expected & lf);
 346
 347   expected := nstr_an3;
 348   CHECK_METHOD(bxer_enc_Nst, AsnValues.an3, expected);
 349   flatten(expected);
 350   CHECK_METHOD(cxer_enc_Nst, AsnValues.an3, expected & lf);
 351
 352   expected := nstr_nn;
 353   CHECK_METHOD(bxer_enc_Nst, AsnValues.nn, expected);
 354   flatten(expected);
 355   CHECK_METHOD(cxer_enc_Nst, AsnValues.nn, expected & lf);
 356
 357   expected := nstr_an3;
 358   CHECK_METHOD(bxer_enc_Nst, AsnValues.an3, expected);
 359   flatten(expected);
 360   CHECK_METHOD(cxer_enc_Nst, AsnValues.an3, expected & lf);
 361
 362   /*******************************************************************/
 363
 364   expected := nstrx_nixtorex;
 365   CHECK_METHOD(bxer_enc_Nstx, AsnValues.nixtorex, expected);
 366   flatten(expected);
 367   CHECK_METHOD(cxer_enc_Nstx, AsnValues.nixtorex, expected & lf);
 368
 369   expected := nstrx_nixtor2ex;
 370   CHECK_METHOD(bxer_enc_Nstx, AsnValues.nixtor2ex, expected);
 371   flatten(expected);
 372   CHECK_METHOD(cxer_enc_Nstx, AsnValues.nixtor2ex, expected & lf);
 373
 374   expected := nstrx_nixtor3ex;
 375   CHECK_METHOD(bxer_enc_Nstx, AsnValues.nixtor3ex, expected);
 376   flatten(expected);
 377   CHECK_METHOD(cxer_enc_Nstx, AsnValues.nixtor3ex, expected & lf);
 378
 379   expected := nstrx_nixtor4ex;
 380   CHECK_METHOD(bxer_enc_Nstx, AsnValues.nixtor4ex, expected);
 381   flatten(expected);
 382   CHECK_METHOD(cxer_enc_Nstx, AsnValues.nixtor4ex, expected & lf);
 383
 384   expected := nstrx_an3ex;
 385   CHECK_METHOD(bxer_enc_Nstx, AsnValues.an3ex, expected);
 386   flatten(expected);
 387   CHECK_METHOD(cxer_enc_Nstx, AsnValues.an3ex, expected & lf);
 388
 389   expected := nstrx_nnx;
 390   CHECK_METHOD(bxer_enc_Nstx, AsnValues.nnx, expected);
 391   flatten(expected);
 392   CHECK_METHOD(cxer_enc_Nstx, AsnValues.nnx, expected & lf);
 393
 394 }
 395
 396 /********* infinite recursion in record-of is OK *********/
 397 type record of Inf Inf;
 398 DECLARE_XER_ENCODERS(Inf, inf);
 399 DECLARE_EXER_ENCODERS(Inf, inf);
 400
 401 const Inf empty  := {}
 402 const Inf level3 := {{{}}}
 403
 404 const universal charstring str_empty := "<Inf/>\n\n";
 405 const universal charstring str3 :=
 406 "<Inf>\n" &
 407 "\t<Inf>\n" &
 408 "\t\t<Inf>\n" &
 409 "\t\t</Inf>\n" &
 410 "\t</Inf>\n" &
 411 "</Inf>\n\n";
 412 const universal charstring str3empty :=
 413 "<Inf>\n" &
 414 "\t<Inf>\n" &
 415 "\t\t<Inf/>\n" &
 416 "\t</Inf>\n" &
 417 "</Inf>\n\n";
 418
 419
 420 testcase encode_inf() runs on Tnested
 421 {
 422   var universal charstring expected;
 423
 424   expected := str_empty;
 425   CHECK_METHOD(bxer_enc_inf, empty, expected);
 426   CHECK_METHOD(exer_enc_inf, empty, expected);
 427   flatten(expected);
 428   CHECK_METHOD(cxer_enc_inf, empty, expected & lf);
 429
 430   expected := str3empty;
 431   CHECK_METHOD(bxer_enc_inf, level3, expected);
 432   CHECK_METHOD(exer_enc_inf, level3, expected);
 433   flatten(expected);
 434   CHECK_METHOD(cxer_enc_inf, level3, expected & lf);
 435 }
 436
 437 testcase decode_inf() runs on Tnested
 438 {
 439   CHECK_DECODE2(        inf, str_empty, Inf, empty);
 440   CHECK_DECODE(exer_dec_inf, str_empty, Inf, empty);
 441
 442   CHECK_DECODE2(        inf, str3empty, Inf, level3);
 443   CHECK_DECODE(exer_dec_inf, str3empty, Inf, level3);
 444
 445   // also check that non-empty element can be decoded
 446   CHECK_DECODE2(        inf, str3     , Inf, level3);
 447   CHECK_DECODE(exer_dec_inf, str3     , Inf, level3);
 448 }
 449
 450 control {
 451   execute(encode_nest());
 452   execute(encode_nest_asn());
 453   execute(decode_nest());
 454
 455   execute(encode_inf());
 456   execute(decode_inf());
 457 }
 458
 459 } // module
 460 with {
 461   encode "XML";
 462   extension "version R8N";
 463 }