regression_test/XML/AbstractBlock/AbstractBlock.ttcn

   1 /******************************************************************************
   2  * Copyright (c) 2000-2016 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  * Contributors:
   9  *   Balasko, Jeno
  10  *   Baranyi, Botond
  11  *
  12  ******************************************************************************/
  13 module AbstractBlock {
  14
  15 // This module contains tests for the ABSTRACT and BLOCK encoding instructions,
  16 // which are generally used in code generated from element substitutions and type
  17 // substitutions in XSD.
  18
  19 type component CT {}
  20
  21 /******* Test 1: Element substitution example *******/
  22 type charstring Member1
  23 with {
  24   variant "name as uncapitalized";
  25   variant "element";
  26 }
  27
  28 type enumerated Member2
  29 {
  30         else_,
  31         something
  32 }
  33 with {
  34   variant "text 'else_' as 'else'";
  35   variant "name as uncapitalized";
  36   variant "element";
  37 }
  38
  39 type record Member3
  40 {
  41         integer bar optional,
  42         float foo optional,
  43         charstring base
  44 }
  45 with {
  46   variant "name as uncapitalized";
  47   variant "element";
  48   variant(bar) "attribute";
  49   variant(foo) "attribute";
  50   variant(base) "untagged";
  51 }
  52
  53 type union Head_group
  54 {
  55         charstring head,
  56         Member1 member1,
  57         Member2 member2,
  58         Member3 member3
  59 }
  60 with {
  61   variant "untagged";
  62   variant(head) "abstract";
  63   variant(member3) "block";
  64 }
  65
  66 type record of Head_group Data
  67 with {
  68   variant "name as uncapitalized";
  69 }
  70
  71 external function f_enc_data(in Data x) return octetstring
  72   with { extension "prototype(convert) encode(XER:XER_EXTENDED)" };
  73
  74 external function f_dec_data(in octetstring x) return Data
  75   with { extension "prototype(convert) decode(XER:XER_EXTENDED)" };
  76
  77 testcase tc_element_substitution() runs on CT
  78 {
  79   // non-blocked and non-abstract fields should be encoded and decoded normally
  80   var Data v_data := { { member1 := "xy" }, { member2 := else_ } };
  81   var octetstring v_exp_enc := char2oct(
  82     "<data xmlns:tns='http://www.example.org/blockExtension'>\n" &
  83     "\t<tns:member1>xy</tns:member1>\n" &
  84     "\t<tns:member2>else</tns:member2>\n" &
  85     "</data>\n\n");
  86
  87   var octetstring v_enc := f_enc_data(v_data);
  88   if (v_enc != v_exp_enc) {
  89     setverdict(fail, "Expected: ", v_exp_enc, ", got: ", v_enc);
  90   }
  91   var Data v_dec := f_dec_data(v_exp_enc);
  92   if (v_dec != v_data) {
  93     setverdict(fail, "Expected: ", v_data, ", got: ", v_dec);
  94   }
  95
  96   // abstract and blocked fields are encoded as before, but cause an error while decoding
  97   v_data := { { head := "abc" } };
  98   v_exp_enc := char2oct(
  99     "<data>\n" &
 100     "\t<head>abc</head>\n" &
 101     "</data>\n\n");
 102
 103   v_enc := f_enc_data(v_data);
 104   if (v_enc != v_exp_enc) {
 105     setverdict(fail, "Expected: ", v_exp_enc, ", got: ", v_enc);
 106   }
 107
 108   @try {
 109     v_dec := f_dec_data(v_exp_enc);
 110     setverdict(fail, "Error expected while decoding ", v_exp_enc);
 111   }
 112   @catch (msg) {
 113     if (not match(msg, pattern "*Index 0: Alternative 'head': Attempting to decode blocked or abstract field.")) {
 114       setverdict(fail, "Incorrect error message received while decoding ", v_exp_enc, " (message: ", msg, ")");
 115     }
 116   }
 117
 118   // another negative test example
 119   v_data := { { member2 := something }, { member3 := { bar := 10, foo := omit, base := "base" } } };
 120   v_exp_enc := char2oct(
 121     "<data xmlns:tns='http://www.example.org/blockExtension'>\n" &
 122     "\t<tns:member2>something</tns:member2>\n" &
 123     "\t<tns:member3 bar='10'>base</tns:member3>\n" &
 124     "</data>\n\n");
 125
 126   v_enc := f_enc_data(v_data);
 127   if (v_enc != v_exp_enc) {
 128     setverdict(fail, "Expected: ", v_exp_enc, ", got: ", v_enc);
 129   }
 130
 131   @try {
 132     v_dec := f_dec_data(v_exp_enc);
 133     setverdict(fail, "Error expected while decoding ", v_exp_enc);
 134   }
 135   @catch (msg) {
 136     if (not match(msg, pattern "*Index 1: Alternative 'member3': Attempting to decode blocked or abstract field.")) {
 137       setverdict(fail, "Incorrect error message received while decoding ", v_exp_enc, " (message: ", msg, ")");
 138     }
 139   }
 140
 141   setverdict(pass);
 142 }
 143
 144 /******* Test 2: Type substitution example *******/
 145 type record ParentType {
 146         record length (1 .. infinity) of charstring foo_list optional,
 147         charstring bar
 148 }
 149 with {
 150         variant "name as uncapitalized";
 151         variant(foo_list) "untagged";
 152         variant(foo_list[-]) "name as 'foo'";
 153 }
 154
 155 type record RestrictedType {
 156         record length (1 .. infinity) of charstring foo_list,
 157         charstring bar
 158 }
 159 with {
 160         variant "name as uncapitalized";
 161         variant(foo_list) "untagged";
 162         variant(foo_list[-]) "name as 'foo'";
 163 }
 164
 165 type union ParentType_derivations {
 166   ParentType    parentType,
 167   RestrictedType restrictedType
 168 }
 169 with {
 170         variant "useType";
 171         variant "name as 'derivation'";
 172         variant(parentType) "abstract";
 173 }
 174
 175 type record of ParentType_derivations Data2
 176 with {
 177   variant "name as 'data'";
 178 }
 179
 180 external function f_enc_data2(in Data2 x) return octetstring
 181   with { extension "prototype(convert) encode(XER:XER_EXTENDED)" };
 182
 183 external function f_dec_data2(in octetstring x) return Data2
 184   with { extension "prototype(convert) decode(XER:XER_EXTENDED)" };
 185
 186 testcase tc_type_substitution() runs on CT
 187 {
 188   // non-blocked and non-abstract fields should be encoded and decoded normally
 189   var Data2 v_data := { { restrictedType := { foo_list := { "first", "second" }, bar := "restricted" } } };
 190   var octetstring v_exp_enc := char2oct(
 191     "<data xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>\n" &
 192     "\t<derivation xsi:type='restrictedType'>\n" &
 193     "\t\t<foo>first</foo>\n" &
 194     "\t\t<foo>second</foo>\n" &
 195     "\t\t<bar>restricted</bar>\n" &
 196     "\t</derivation>\n" &
 197     "</data>\n\n");
 198
 199   var octetstring v_enc := f_enc_data2(v_data); // '>' missing from one of the tags, requires Bence's modification
 200   /*if (v_enc != v_exp_enc) {
 201     setverdict(fail, "Expected: ", v_exp_enc, ", got: ", v_enc);
 202   }*/
 203   var Data2 v_dec := f_dec_data2(v_exp_enc);
 204   if (v_dec != v_data) {
 205     setverdict(fail, "Expected: ", v_data, ", got: ", v_dec);
 206   }
 207
 208   // abstract and blocked fields are encoded as before, but cause an error while decoding
 209   v_data := { { parentType := { foo_list := omit, bar := "parent" } } };
 210   v_exp_enc := char2oct(
 211     "<data>\n" &
 212     "\t<derivation>\n" &
 213     "\t\t<bar>parent</bar>\n" &
 214     "\t</derivation>\n" &
 215     "</data>\n\n");
 216
 217   v_enc := f_enc_data2(v_data); // '>' missing
 218   /*if (v_enc != v_exp_enc) {
 219     setverdict(fail, "Expected: ", v_exp_enc, ", got: ", v_enc);
 220   }*/
 221
 222   @try {
 223     v_dec := f_dec_data2(v_exp_enc);
 224     setverdict(fail, "Error expected while decoding ", v_exp_enc);
 225   }
 226   @catch (msg) {
 227     if (not match(msg, pattern "*Index 0: Alternative 'parentType': Attempting to decode blocked or abstract field.")) {
 228       setverdict(fail, "Incorrect error message received while decoding ", v_exp_enc, " (message: ", msg, ")");
 229     }
 230   }
 231
 232   setverdict(pass);
 233 }
 234
 235 control {
 236   execute(tc_element_substitution());
 237   execute(tc_type_substitution());
 238 }
 239
 240 }
 241 with {
 242   encode "XML";
 243   variant "namespace as 'http://www.example.org/blockExtension' prefix 'tns'";
 244   variant "controlNamespace 'http://www.w3.org/2001/XMLSchema-instance' prefix 'xsi'";
 245 }