Sync with 5.4.0

[deliverable/titan.core.git] / regression_test / XML / HN15589 / HN15589.ttcnpp

/******************************************************************************
 * Copyright (c) 2000-2015 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
 ******************************************************************************/
module HN15589 {
modulepar boolean Namespaces_verbose := false;
#define   verbose Namespaces_verbose
#include "../macros.ttcnin"

import from xtdp all;

type component HN {}

group xtdl {
  type union GroupA
  {
    universal charstring elem_A
  }
  with {
    variant "untagged";
    variant (elem_A) "name as capitalized";
  };
}
with {
  variant "namespace as 'urn:xtdl' prefix 'xtdl' "
  variant "elementFormQualified";
}

group xtdp {
  // in the original, xtdl is included by xtdp
  type record ComplexB
  {
    GroupA groupA
  }
  // GroupA is untagged, so the namespace is redundant
  //with {
  //  variant (groupA) "namespace as 'urn:xtdl' prefix 'xtdl'";
  //};


  type record Elem_B
  {
    ComplexB subElem_B
  }
  with {
    variant "element";
  };

}
with {
  variant "namespace as 'urn:xtdp' "; // no prefix
  // by default, form is unqualified for local types
}

external function enc_Elem_B (in Elem_B p_message) return octetstring
with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}

external function dec_Elem_B (in octetstring p_oct, out Elem_B p_message) return integer
with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}

const charstring expected :=
"<tq0002:Elem_B xmlns:tq0002='urn:xtdp' xmlns:tq0001='urn:xtdl'>\n" &
"\t<subElem_B>\n" &
"\t\t<tq0001:Elem_A>B</tq0001:Elem_A>\n" &
"\t</subElem_B>\n" &
"</tq0002:Elem_B>\n\n";

const octetstring exp_o := char2oct(expected);

testcase tc_encdec() runs on HN
{
  var octetstring encoded := enc_Elem_B({subElem_B:= {groupA := {elem_A:="B"}}});
  //action(encoded);

  var Elem_B b;
  // decode what we encoded
  var integer rez := dec_Elem_B(encoded, b);
  if (rez == 0) { setverdict(pass); }
  else { setverdict(fail, "Retcode=", rez); }

  if (encoded == exp_o) { setverdict(pass); }
  else {
    setverdict(fail, "mismatch: ");
    log("G0T: ", encoded);
    log("EXP: ", exp_o);
  }

  // decode what we think should be encoded
  rez := dec_Elem_B(exp_o, b);
  if (rez == 0) { setverdict(pass); }
  else { setverdict(fail, "Retcode=", rez); }

  // decode what we encoded
  rez := dec_Elem_B(encoded, b);
  if (rez == 0) { setverdict(pass); }
  else { setverdict(fail, "Retcode=", rez); }

}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

group FlipFlop {
  type record Outer {
    Inner i
  }
  with {
    variant "element";
  }

  type record Inner {
    Inner2 i2
  } // unqualified by default
  with {
    variant (i2) "form as qualified";
  }

  type record Inner2 {
    record of Vec3 v3_list
  }
  with {
//    variant "element";
    variant (v3_list) "untagged"
    variant (v3_list[-]) "name as 'v3' "
  }

  type record Vec3 {
    Vec4 v4
  }
  with {
    variant (v4) "form as qualified"
  }

  type record Vec4 {
    record of U5 u5_list
  }
  with {
    variant (u5_list) "untagged"
    variant (u5_list[-]) "name as 'u5'"
  }

  type record U5 {
    union {
      U6 u6,
      record {} e6
    } choice
  }
  with {
    variant (choice) "untagged"
  }

  type union U6 {
    charstring s,
    record {} e
  }

} // group
with {
  variant "namespace as 'urn:xtdp' "; // no prefix; same URI as above
}

external function enc_Outer (in Outer p_message) return octetstring
with {extension "prototype(convert) encode (XER:XER_EXTENDED)"}

external function dec_Outer (in octetstring p_oct, out Outer p_message) return integer
with {extension "prototype(backtrack) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}

const charstring outstr :=
"<tq0002:Outer xmlns:tq0002='urn:xtdp'>\n" &
"\t<i>\n" &
"\t\t<tq0002:i2>\n" &
"\t\t\t<v3>\n" &
"\t\t\t\t<tq0002:v4>\n" &
"\t\t\t\t\t<u5>\n" &
"\t\t\t\t\t\t<u6>\n" &
"\t\t\t\t\t\t\t<s>Hello</s>\n" &
"\t\t\t\t\t\t</u6>\n" &
"\t\t\t\t\t</u5>\n" &
"\t\t\t\t\t<u5>\n" &
"\t\t\t\t\t\t<u6>\n" &
"\t\t\t\t\t\t\t<e/>\n" &
"\t\t\t\t\t\t</u6>\n" &
"\t\t\t\t\t</u5>\n" &
"\t\t\t\t\t<u5>\n" &
"\t\t\t\t\t\t<e6/>\n" &
"\t\t\t\t\t</u5>\n" &
"\t\t\t\t</tq0002:v4>\n" &
"\t\t\t</v3>\n" &
"\t\t</tq0002:i2>\n" &
"\t</i>\n" &
"</tq0002:Outer>\n\n";
//const octetstring ooo := char2oct(outstr);

testcase tc_flipflop() runs on HN
{
  const Outer limits := {
    i := {
      i2 := {
        v3_list := {
          {
            v4 := {
              u5_list := {
                {
                  choice := {
                    u6 := {
                      s := "Hello"
                    }
                  }
                },
                {
                  choice := {
                    u6 := {
                      e := {}
                    }
                  }
                },
                {
                  choice := {
                    e6 := {}
                  }
                }
              }
            }
          }
//          { // Vec4
//            /* U5 */ { u6 := { s := "Hello"} },
//            /* U5 */ { u6 := { e := { } } },
//            /* U5 */ { e6 := {} }
//          }
        }
      }
    }
  }
  var octetstring encoded := enc_Outer(limits);
  action(encoded);

  var charstring s_encoded := oct2char(encoded);

  if (match(s_encoded, outstr)) { setverdict(pass); }
  else { setverdict(fail, match(s_encoded, outstr) ); }

  var Outer space;
  var integer rez := dec_Outer(encoded, space);
  if (rez == 0) { setverdict(pass); }
  else {
    setverdict(fail, "result=", rez);
  }
  if (match(space, limits)) { setverdict(pass); }
  else { setverdict(fail, match(space, limits) ); }
}

/* * * * * * * * * * * * * * * * * * */
external function enc_msg (in XTDP_Message p_oct) return octetstring
with {extension "prototype(convert) encode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}

external function dec_msg (in octetstring o) return XTDP_Message
with {extension "prototype(convert) decode (XER:XER_EXTENDED) errorbehavior(ALL:WARNING)"}

const XTDP_Message source_message := {
  transactionID := 2,
  choice := {
    xTDP_AddRequests := {
      xTDP_AddRequest_list := {
        {
          requestId := 2,
          parentWidgetId := omit,
          widgets := {
            window := {
              height := 300.000000,
              id := "MyNewEPTFMainWindow",
              orientation := vertical,
              title := "My TTCN constructed window",
              width := 800.000000,
              image_list := {
              },
              embeddedwidgets := {
                embeddedwidget_list := {
                  {
                    tabbox := {
                      disabled := omit,
                      flex := omit,
                      id := "EPTF_Main_Tabbox",
                      layout := omit,
                      tabs := {
                        {}
                      },
                      tabpanels := {
                        {}
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

testcase tc_xtdp() runs on HN // not from control part
{
  var octetstring o := enc_msg(source_message);
  action(o);

  var XTDP_Message roundtrip := dec_msg(o);
  if (roundtrip == source_message) { setverdict(pass); }
  else { setverdict(fail); }
}

control {
  execute(tc_encdec());
  execute(tc_flipflop());
}

}
with {
encode "XML";
variant "controlNamespace 'http://www.w3.org/2001/XMLSchema-instance' prefix 'xsi'";
}