Sync with 5.4.0

[deliverable/titan.core.git] / regression_test / XML / EXER-whitepaper / Attribute.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 Attribute
{
modulepar boolean Attribute_verbose := false;
#define verbose Attribute_verbose
#include "../macros.ttcnin"

type component ATR {}

type charstring Color
with {
  variant "attribute"
}

type record ProductA {
  Color      color,
  charstring material,
  charstring size,
  universal charstring size2,
  charstring name,
  integer    price
}
with {
  variant (color) "attribute" // it is not enough that Color has "attribute"
  variant (material) "attribute"
  variant (size) "attribute"
  variant (size2) "attribute"
}

DECLARE_XER_ENCODERS (ProductA, prodA);
DECLARE_EXER_ENCODERS(ProductA, prodA);

// Decoder function which treats ET_INVAL_MSG as a warning.
// Everything else is still a dynamic testcase error.
external function exer_dec_prodA_expect_inval(in octetstring o, out ProductA pa) return integer
with { extension "prototype(backtrack) decode(XER:XER_EXTENDED) errorbehavior(INVAL_MSG:WARNING,INCOMPL_MSG:WARNING)" }


const ProductA shoes := {
  color := "blue",
  material := "suede",
  size := "1'2\"",
  size2:= "1'2\"",
  name := "Shoes",
  price:= 25
}

const universal charstring str_shoes_e :=
"<ProductA color=\'blue\' material=\'suede\' size='1&apos;2&quot;' size2='1&apos;2&quot;'>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>25</price>\n" &
"</ProductA>\n" &
"\n";

const universal charstring str_shoes_nocolor :=
"<ProductA material=\'suede\' size='1&apos;2\"' size2='1&apos;2\"'>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>25</price>\n" &
"</ProductA>\n" &
"\n";

const universal charstring str_shoes_nosize :=
"<ProductA color=\'blue\' material=\'suede\' size2='1&apos;2\"'>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>25</price>\n" &
"</ProductA>\n" &
"\n";

const universal charstring str_shoes_nosize2 :=
"<ProductA color=\'blue\' material=\'suede\' size='1&apos;2\"'>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>25</price>\n" &
"</ProductA>\n" &
"\n";

const universal charstring str_shoes_extra :=
"<ProductA color=\'blue\' speed=\'high\' material=\'suede\' size='1&apos;2\"' size2='1&apos;2\"'>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>25</price>\n" &
"</ProductA>\n" &
"\n";

const universal charstring str_shoes_extra2 :=
"<ProductA color=\'blue\' super:speed=\'high\' material=\'suede\' size='1&apos;2\"' size2='1&apos;2\"' " &
"xmlns:super='duper'>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>25</price>\n" &
"</ProductA>\n" &
"\n";

const universal charstring str_shoes_e_jumbled :=
"<ProductA material=\'suede\' color=\'blue\' size='1&apos;2\"' size2='1&apos;2\"'>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>25</price>\n" &
"</ProductA>\n" &
"\n";

const universal charstring str_shoes_b :=
"<ProductA>\n" &
"\t<color>blue</color>\n" &
"\t<material>suede</material>\n" &
"\t<size>1&apos;2&quot;</size>\n" &
"\t<size2>1&apos;2&quot;</size2>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>25</price>\n" &
"</ProductA>\n" &
"\n";

// Test the escaping of TAB, CR, LF in attributes: X.693 (11/2008), clause 20.3.15
const ProductA nutrimatic := {
  color := "black",
  material := "unknown",
  size  :=
  "When the 'Drink' button is pressed it makes an instant but highly detailed" &
  "\texamination of the subject's taste buds,\r\n" &
  "a spectroscopic analysis of the subject's metabolism,\r\n" &
  "and then sends tiny experimental signals down the neural pathways" &
  "\tto the taste centres of the subject's brain to see what is likely to be well received.",
  size2 :=
  "\tHowever, no-one knows quite why it does this because it then invariably delivers\r\n" &
  "a cupful of liquid that is almost, but not quite, entirely unlike tea.\r\n",
  name  := "Nutrimatic Drinks Dispenser",
  price := 42
}

const universal charstring str_nutrimatic_e :=
"<ProductA color='black' material='unknown' " &

"size='When the &apos;Drink&apos; button is pressed it makes an instant but highly detailed" &
"&#x09;examination of the subject&apos;s taste buds,&#x0D;&#x0A;" &
"a spectroscopic analysis of the subject&apos;s metabolism,&#x0D;&#x0A;" &
"and then sends tiny experimental signals down the neural pathways" &
"&#x09;to the taste centres of the subject&apos;s brain to see what is likely to be well received.' " &

"size2='&#x09;However, no-one knows quite why it does this because it then invariably delivers&#x0D;&#x0A;" &
"a cupful of liquid that is almost, but not quite, entirely unlike tea.&#x0D;&#x0A;'>\n" &

"\t<name>Nutrimatic Drinks Dispenser</name>\n" &
"\t<price>42</price>\n" &
"</ProductA>\n\n";

const universal charstring str_nutrimatic_b :=
"<ProductA>\n" &
"\t<color>black</color>\n" &
"\t<material>unknown</material>\n" &

"\t<size>When the &apos;Drink&apos; button is pressed it makes an instant but highly detailed" &
"\texamination of the subject&apos;s taste buds,\r\n" &
"a spectroscopic analysis of the subject&apos;s metabolism,\r\n" &
"and then sends tiny experimental signals down the neural pathways" &
"\tto the taste centres of the subject&apos;s brain to see what is likely to be well received.</size>\n" &

"\t<size2>\tHowever, no-one knows quite why it does this because it then invariably delivers\r\n" &
"a cupful of liquid that is almost, but not quite, entirely unlike tea.\r\n</size2>\n" &

"\t<name>Nutrimatic Drinks Dispenser</name>\n" &
"\t<price>42</price>\n" &
"</ProductA>\n\n";

// The result from BXER decoding.
// All combinations of \r, \n, \r\n are reduced to \n by libxml
const ProductA nutrimatic_bxer := {
  color := "black",
  material := "unknown",
  size  :=
  "When the 'Drink' button is pressed it makes an instant but highly detailed" &
  "\texamination of the subject's taste buds,\n" &
  "a spectroscopic analysis of the subject's metabolism,\n" &
  "and then sends tiny experimental signals down the neural pathways" &
  "\tto the taste centres of the subject's brain to see what is likely to be well received.",
  size2 :=
  "\tHowever, no-one knows quite why it does this because it then invariably delivers\n" &
  "a cupful of liquid that is almost, but not quite, entirely unlike tea.\n",
  name  := "Nutrimatic Drinks Dispenser",
  price := 42
}

const ProductA empty := {
  color := "",
  material := "antimatter",
  size  := "",
  size2 := "",
  name  := "",
  price := 0
}

const universal charstring str_empty_e :=
"<ProductA color=\'\' material=\'antimatter\' size='' size2=''>\n" &
"\t<name/>\n" &
"\t<price>0</price>\n" &
"</ProductA>\n" &
"\n";

const universal charstring str_empty_e_jumbled :=
"<ProductA material=\'antimatter\' color=\'\' size='' size2=''>\n" &
"\t<name/>\n" &
"\t<price>0</price>\n" &
"</ProductA>\n" &
"\n";

const universal charstring str_empty_b :=
"<ProductA>\n" &
"\t<color/>\n" &
"\t<material>antimatter</material>\n" &
"\t<size/>\n" &
"\t<size2/>\n" &
"\t<name/>\n" &
"\t<price>0</price>\n" &
"</ProductA>\n" &
"\n";

testcase enc_atr() runs on ATR
{
  CHECK_METHOD(bxer_enc_prodA, shoes, str_shoes_b);
  CHECK_METHOD(exer_enc_prodA, shoes, str_shoes_e);

  CHECK_METHOD(bxer_enc_prodA, empty, str_empty_b);
  CHECK_METHOD(exer_enc_prodA, empty, str_empty_e);

  CHECK_METHOD(bxer_enc_prodA, nutrimatic, str_nutrimatic_b);
  CHECK_METHOD(exer_enc_prodA, nutrimatic, str_nutrimatic_e);
}

testcase dec_atr() runs on ATR
{
  CHECK_DECODE(bxer_dec_prodA, str_shoes_b, ProductA, shoes);
  CHECK_DECODE(exer_dec_prodA, str_shoes_e, ProductA, shoes);
  // check that attributes are accepted in any order
  CHECK_DECODE(exer_dec_prodA, str_shoes_e_jumbled, ProductA, shoes);

  // Decoding bogus attribute. Should be DTE instead of segfault.
  //   CHECK_DECODE(exer_dec_prodA, str_shoes_extra, ProductA, shoes);
  CHECK_DECODE_FAIL_AND_COMPARE(exer_dec_prodA_expect_inval, str_shoes_extra, ProductA, shoes);
  CHECK_DECODE_FAIL_AND_COMPARE(exer_dec_prodA_expect_inval, str_shoes_extra2, ProductA, shoes);

  // Decoding not enough attributes
  CHECK_DECODE_FAIL(exer_dec_prodA_expect_inval, str_shoes_nocolor, ProductA);
  CHECK_DECODE_FAIL(exer_dec_prodA_expect_inval, str_shoes_nosize , ProductA);
  CHECK_DECODE_FAIL(exer_dec_prodA_expect_inval, str_shoes_nosize2, ProductA);

  CHECK_DECODE(bxer_dec_prodA, str_empty_b, ProductA, empty);
  CHECK_DECODE(exer_dec_prodA, str_empty_e, ProductA, empty);
  // check that attributes are accepted in any order
  CHECK_DECODE(exer_dec_prodA, str_empty_e_jumbled, ProductA, empty);

  CHECK_DECODE(bxer_dec_prodA, str_nutrimatic_b, ProductA, nutrimatic_bxer);
  CHECK_DECODE(exer_dec_prodA, str_nutrimatic_e, ProductA, nutrimatic);
}

/*
Attributes must be at front; mixture is not allowed

type record mix {
  integer yes,
  integer no,
  integer maybe
}
with {
  variant (yes) "attribute";
  variant (maybe) "attribute";
}
*/

type record NSProduct {
  Color      color,
  charstring material,
  charstring size,
  universal charstring size2,
  charstring name,
  integer    price
}
with {
  variant (color) "attribute" // it is not enough that Color has "attribute"
  variant (material) "attribute"
  variant (material) "namespace as 'foo:bar:baz' prefix 'raw' "
  variant (material) "form as qualified";
  variant (size) "attribute"
  variant (size2) "attribute"
}

/*
type ProductA NSProductWTF
with {
  variant (materisl) "namespace as 'foo:bar:baz' prefix 'raw' "
  // Uh-oh, this should not compile
}
*/

DECLARE_XER_ENCODERS (NSProduct, nsprod);
DECLARE_EXER_ENCODERS(NSProduct, nsprod);

const NSProduct nsshoes := {
  color := "black",
  material := "lac",
  size := "1'7\"",
  size2:= "1'9\"",
  name := "Shoes",
  price:= 200
}

const universal charstring str_nsshoes_e :=
"<NSProduct xmlns:raw='foo:bar:baz' color=\'black\' raw:material=\'lac\' size='1&apos;7&quot;' size2='1&apos;9&quot;'>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>200</price>\n" &
"</NSProduct>\n" &
"\n";

const universal charstring str_nsshoes_e_jumbled :=
"<NSProduct xmlns:raw='foo:bar:baz' raw:material=\'lac\' color=\'black\' size='1&apos;7&quot;' size2='1&apos;9&quot;'>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>200</price>\n" &
"</NSProduct>\n" &
"\n";

const universal charstring str_nsshoes_b :=
"<NSProduct>\n" &
"\t<color>black</color>\n" &
"\t<material>lac</material>\n" &
"\t<size>1&apos;7&quot;</size>\n" &
"\t<size2>1&apos;9&quot;</size2>\n" &
"\t<name>Shoes</name>\n" &
"\t<price>200</price>\n" &
"</NSProduct>\n" &
"\n";


testcase enc_atrns() runs on ATR
{
  CHECK_METHOD(bxer_enc_nsprod, nsshoes, str_nsshoes_b);
  CHECK_METHOD(exer_enc_nsprod, nsshoes, str_nsshoes_e);
}

testcase dec_atrns() runs on ATR
{
  CHECK_DECODE(bxer_dec_nsprod, str_nsshoes_b, NSProduct, nsshoes);
  CHECK_DECODE(exer_dec_nsprod, str_nsshoes_e, NSProduct, nsshoes);
  // check that attributes are accepted in any order
  CHECK_DECODE(exer_dec_nsprod, str_nsshoes_e_jumbled, NSProduct, nsshoes);
}

group HL19919 {

type record Window {
  float height optional,
  record of union {
    boolean truthiness,
    integer length_
  } choice_list
}
with {
  variant /* Window */ "element"; // otherwise form=unqualified
  variant (height) "attribute";
  variant (choice_list) "untagged";
variant (choice_list[-]) "untagged";
}

external function dec_w(in octetstring o) return Window
with { extension "prototype(convert) decode(XER:XER_EXTENDED) errorbehavior(ALL:ERROR)" }

/* Regression test for HL19919. XML decoding could get stuck in one place,
   (endless loop) failing to advance when decoding attributes. */
testcase hl19919() runs on ATR
{
  var octetstring input := char2oct(
    "<xul:Window xmlns:xul='there.is.only.xul' height='3.1415' >\n" &
    "</xul:Window>\n\n"
    );

  var Window w := dec_w(input);
  if (isvalue(w) and w.height == 3.1415 and 0 == lengthof(w.choice_list))
  { setverdict(pass); }
  else { setverdict(fail, w, "unbound"); }
}

}
with {
  variant "namespace as 'there.is.only.xul' prefix 'xul' ";
}

group SchemaLocation {
// The decoder should ignore xsi:schemaLocation attributes 
// (instead of throwing an "Unexpected attribute ..." error)

type record Something {
  bitstring bs optional,
  integer num,
  charstring cs
} with {
  variant "name as uncapitalized";
  variant(bs) "attribute";
}

const universal charstring c_schema_loc_str :=
"<something xmlns=\"http://www.somewhere.com\" " &
"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " &
"xsi:schemaLocation=\"www.thereareschemashere.com\">\n"&
"\t<num>19</num>\n" &
"\t<cs>nothing</cs>\n" &
"</something>";

const Something c_schema_loc := { bs := omit, num := 19, cs := "nothing" };

DECLARE_EXER_ENCODERS(Something, smthn);

testcase dec_atr_schemaloc() runs on ATR
{
  CHECK_DECODE(exer_dec_smthn, c_schema_loc_str, Something, c_schema_loc);
}

} with {
  variant "namespace as 'http://www.somewhere.com' prefix 'smw'";
  variant "controlNamespace 'http://www.w3.org/2001/XMLSchema-instance' prefix 'xsi'";
  variant "elementFormQualified";
}


control {
  execute(enc_atr());
  execute(dec_atr());

  execute(enc_atrns());
  execute(dec_atrns());

  execute(hl19919(), 5.0); // too bad the timer can't save the testcase from its endless loop

  execute(dec_atr_schemaloc());
}

}
with {
encode "XML"
}