Sync with 5.4.2

[deliverable/titan.core.git] / regression_test / XML / EXER-whitepaper / Order.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 Order {

// USE-ORDER tests straight out of the whitepaper

modulepar boolean Order_verbose := false;
#define verbose Order_verbose
#include "../macros.ttcnin"

type component Ord {}

// Example 1: "Plain" USE-ORDER
type record UOProductO {
  record of enumerated { id, name, price, color } order,
  charstring available, // this is not in the whitepaper
  integer id,
  charstring name,
  float price,
  charstring color
}
with {
  variant "element";
  variant "useOrder";
  variant "namespace as 'http://www.example.com' prefix 'exm'";
  variant (available) "attribute";
}

DECLARE_XER_ENCODERS(UOProductO, prodO);
DECLARE_EXER_ENCODERS(UOProductO, prodO);

const UOProductO uoprod := {
  order := { id, color, price, name },
  available := "<true/>",
  id    := 100,
  name  := "shirt",
  price := 12.23,
  color := "red"
}

const universal charstring str_prod_e :=
"<exm:UOProductO xmlns:exm=\'http://www.example.com\' available=\'&lt;true/&gt;\'>\n" &
"\t<id>100</id>\n" &
"\t<color>red</color>\n" &
"\t<price>12.230000</price>\n" &
"\t<name>shirt</name>\n" &
"</exm:UOProductO>\n" &
"\n";

const universal charstring str_prod_b :=
"<UOProductO>\n" &
"\t<order>\n" &
"\t\t<id/><color/><price/><name/>\n" &
"\t</order>\n" &
"\t<available>&lt;true/&gt;</available>\n" &
"\t<id>100</id>\n" &
"\t<name>shirt</name>\n" &
"\t<price>12.230000</price>\n" &
"\t<color>red</color>\n" &
"</UOProductO>\n" &
"\n";

testcase enc_uo() runs on Ord
{
  CHECK_METHOD(bxer_enc_prodO, uoprod, str_prod_b);
  CHECK_METHOD(exer_enc_prodO, uoprod, str_prod_e);
}

testcase dec_uo() runs on Ord
{
  CHECK_DECODE(bxer_dec_prodO, str_prod_b, UOProductO, uoprod);
  CHECK_DECODE(exer_dec_prodO, str_prod_e, UOProductO, uoprod);
}

// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

// Example 2: USE-ORDER and EMBED-VALUES
type record UOProductEmb {
  record length(5) of universal charstring embed,
  record of enumerated { id, name, price, color } order,
  integer id,
  charstring name,
  float price,
  charstring color
}
with {
  variant "element";
  variant "useOrder";
  variant "embedValues";
  variant "namespace as 'http://www.example.com' prefix 'exm'";
}

DECLARE_XER_ENCODERS(UOProductEmb, prod5);
DECLARE_EXER_ENCODERS(UOProductEmb, prod5);

const UOProductEmb prod5 := {
  embed := {"Order Id ", "", "", "US Dollars", "" },
  order := { id, color, price, name },
  id    := 100,
  name  := "shirt",
  price := 12.23,
  color := "red"
}

const universal charstring str_prod5_e :=
"<exm:UOProductEmb xmlns:exm=\'http://www.example.com\'>Order Id " &
"<id>100</id><color>red</color><price>12.230000</price>US Dollars<name>shirt</name></exm:UOProductEmb>" &
"\n";

const universal charstring str_prod5_b :=
"<UOProductEmb>\n" &
"\t<embed>\n" &
"\t\t<UNIVERSAL_CHARSTRING>Order Id </UNIVERSAL_CHARSTRING>\n" &
"\t\t<UNIVERSAL_CHARSTRING/>\n" &
"\t\t<UNIVERSAL_CHARSTRING/>\n" &
"\t\t<UNIVERSAL_CHARSTRING>US Dollars</UNIVERSAL_CHARSTRING>\n" &
"\t\t<UNIVERSAL_CHARSTRING/>\n" &
"\t</embed>\n" &
"\t<order>\n" &
"\t\t<id/><color/><price/><name/>\n" &
"\t</order>\n" &
"\t<id>100</id>\n" &
"\t<name>shirt</name>\n" &
"\t<price>12.230000</price>\n" &
"\t<color>red</color>\n" &
"</UOProductEmb>\n" &
"\n";

testcase enc_uo_emb() runs on Ord
{
  CHECK_METHOD(bxer_enc_prod5, prod5, str_prod5_b);
  CHECK_METHOD(exer_enc_prod5, prod5, str_prod5_e);
}

testcase dec_uo_emb() runs on Ord
{
  var UOProductEmb expected := prod5;
  CHECK_DECODE(bxer_dec_prod5, str_prod5_b, UOProductEmb, expected);
  CHECK_DECODE(exer_dec_prod5, str_prod5_e, UOProductEmb, expected);
}

// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

// Example 3: USE-ORDER and USE-NIL
type record UOProductNil {
  record of enumerated { id, name, price, color } order,
  boolean available, // not in the whitepaper
  UOProductInfo info optional
}
with {
  variant "element";
  variant "useOrder";
  variant "useNil";
  variant (available) "attribute";
  variant "namespace as 'http://www.example.com' prefix 'exm'";
}

type record UOProductInfo {
  integer id,
  charstring name,
  float price,
  charstring color
}

DECLARE_XER_ENCODERS(UOProductNil, prod0);
DECLARE_EXER_ENCODERS(UOProductNil, prod0);

// ... ... present ... ...

const UOProductNil prod0 := {
  order := { id, color, price, name },
  available := true,
  info := {
    id    := 100,
    name  := "shirt",
    price := 12.23,
    color := "red"
  }
}

const universal charstring str_prod0_e :=
"<exm:UOProductNil xmlns:exm=\'http://www.example.com\' available=\'true\'>\n" &
"\t<id>100</id>\n" &
"\t<color>red</color>\n" &
"\t<price>12.230000</price>\n" &
"\t<name>shirt</name>\n" &
"</exm:UOProductNil>\n" &
"\n";

// 'nil' attribute present but says 'no'
const universal charstring str_prod0nonil_e :=
"<exm:UOProductNil available=\'true\' xmlns:exm=\'http://www.example.com\' " &
"xmlns:xsi=\'http://www.w3.org/2001/XMLSchema-instance\' xsi:nil=\'nyet\'>\n" &
"\t<id>100</id>\n" &
"\t<color>red</color>\n" &
"\t<price>12.230000</price>\n" &
"\t<name>shirt</name>\n" &
"</exm:UOProductNil>\n" &
"\n";

const universal charstring str_prod0_b :=
"<UOProductNil>\n" &
"\t<order>\n" &
"\t\t<id/><color/><price/><name/>\n" &
"\t</order>\n" &
"\t<available><true/></available>\n" &
"\t<info>\n" &
"\t\t<id>100</id>\n" &
"\t\t<name>shirt</name>\n" &
"\t\t<price>12.230000</price>\n" &
"\t\t<color>red</color>\n" &
"\t</info>\n" &
"</UOProductNil>\n" &
"\n";

testcase enc_uo_nil_present() runs on Ord
{
  CHECK_METHOD(bxer_enc_prod0, prod0, str_prod0_b);
  CHECK_METHOD(exer_enc_prod0, prod0, str_prod0_e);
}

testcase dec_uo_nil_present() runs on Ord
{
  CHECK_DECODE(bxer_dec_prod0, str_prod0_b, UOProductNil, prod0);
  CHECK_DECODE(exer_dec_prod0, str_prod0_e, UOProductNil, prod0);
  CHECK_DECODE(exer_dec_prod0, str_prod0nonil_e, UOProductNil, prod0);
}

// Example 4: ... ... absent ... ...

const UOProductNil prod0nil := {
  order := {  },
  available := false,
  info := omit
}

const universal charstring str_prod0nil_e :=
"<exm:UOProductNil xmlns:exm=\'http://www.example.com\' " &
"xmlns:xsi=\'http://www.w3.org/2001/XMLSchema-instance\' " &
"available=\'false\' xsi:nil=\'true\'/>\n" &
"\n";

const universal charstring str_prod0nil_b :=
"<UOProductNil>\n" &
"\t<order/>\n" &
"\t<available><false/></available>\n" &
"</UOProductNil>\n" &
"\n";

testcase enc_uo_nil_absent() runs on Ord
{
  CHECK_METHOD(bxer_enc_prod0, prod0nil, str_prod0nil_b);
  CHECK_METHOD(exer_enc_prod0, prod0nil, str_prod0nil_e);
}

testcase dec_uo_nil_absent() runs on Ord
{
  CHECK_DECODE(bxer_dec_prod0, str_prod0nil_b, UOProductNil, prod0nil);
  CHECK_DECODE(exer_dec_prod0, str_prod0nil_e, UOProductNil, prod0nil);
}

// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

// Example 5: USE-ORDER and ANY-ELEMENT

type record UORecordAny {
  record of enumerated { id, anyElem, bytes, anyElem2 } order,
  integer id,
  universal charstring anyElem,
  octetstring bytes,
  universal charstring anyElem2
} with {
  variant "useOrder";
  variant (anyElem) "anyElement";
  variant (anyElem2) "anyElement";
}

DECLARE_EXER_ENCODERS(UORecordAny, uo_any);

const UORecordAny any0 := {
  order := { bytes, anyElem, anyElem2, id },
  id := 2,
  anyElem := "<something/>",
  bytes := 'A1'O,
  anyElem2 := "<field>123</field>"
};

const universal charstring str_any0 :=
  "<UORecordAny>\n" &
  "\t<bytes>A1</bytes>\n" &
  "\t<something/>\n" &
  "\t<field>123</field>\n" &
  "\t<id>2</id>\n" &
  "</UORecordAny>\n\n";

testcase enc_uo_any() runs on Ord
{
  CHECK_METHOD(exer_enc_uo_any, any0, str_any0);
}

testcase dec_uo_any() runs on Ord
{
  CHECK_DECODE(exer_dec_uo_any, str_any0, UORecordAny, any0);
}

// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

// Example 6: USE-ORDER with only one element that is optional

type record UORecordOneOpt {
  record of enumerated { id } order,
  integer id optional
} with {
  variant "useOrder";
}

DECLARE_EXER_ENCODERS(UORecordOneOpt, uo_one_opt);

const UORecordOneOpt one_opt := {
  order := { id },
  id := 2
};

const universal charstring str_one_opt_e :=
  "<UORecordOneOpt>\n" &
  "\t<id>2</id>\n" &
  "</UORecordOneOpt>\n\n";

testcase enc_uo_one_opt() runs on Ord
{
  CHECK_METHOD(exer_enc_uo_one_opt, one_opt, str_one_opt_e);
}

testcase dec_uo_one_opt() runs on Ord
{
  CHECK_DECODE(exer_dec_uo_one_opt, str_one_opt_e, UORecordOneOpt, one_opt);
}

// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

// Example 7: USE-ORDER with only one record element that is optional

type record UORecordOneOpt2 {
  record of enumerated { id } order,
  RecordOneOpt id optional
} with {
  variant "useOrder";
}

type record RecordOneOpt {
  integer identity
}

DECLARE_EXER_ENCODERS(UORecordOneOpt2, uo_one_opt2);

const UORecordOneOpt2 one_opt2 := {
  order := { id },
  id := { identity := 2 }
};

const universal charstring str_one_opt2_e :=
  "<UORecordOneOpt2>\n" &
  "\t<id>\n" &
  "\t\t<identity>2</identity>\n" &
  "\t</id>\n" &
  "</UORecordOneOpt2>\n\n";

testcase enc_uo_one_opt2() runs on Ord
{
  CHECK_METHOD(exer_enc_uo_one_opt2, one_opt2, str_one_opt2_e);
}

testcase dec_uo_one_opt2() runs on Ord
{
  CHECK_DECODE(exer_dec_uo_one_opt2, str_one_opt2_e, UORecordOneOpt2, one_opt2);
}

// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

control {
  execute(enc_uo());
  execute(dec_uo());

  execute(enc_uo_emb());
  execute(dec_uo_emb());

  execute(enc_uo_nil_present());
  execute(enc_uo_nil_absent());
  execute(dec_uo_nil_present());
  execute(dec_uo_nil_absent());

  execute(enc_uo_any());
  execute(dec_uo_any());

  execute(enc_uo_one_opt());
  execute(dec_uo_one_opt());

  execute(enc_uo_one_opt2());
  execute(dec_uo_one_opt2());
}

}
with {
encode "XML"
variant "controlNamespace 'http://www.w3.org/2001/XMLSchema-instance' prefix 'xsi'"
/*
A "namespace" attribute here would have the equivalent effect of

NAMESPACE ALL AS ...

rather than

NAMESPACE ALL, ALL IN ALL AS ...

because (at least for a record or set type) unqualified attributes stop there
and are not propagated to the component.
*/

}