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