/******************************************************************************
 * Copyright (c) 2000-2016 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
 *
 * Contributors:
 *   Balasko, Jeno
 *   Raduly, Csaba
 *
 ******************************************************************************/
module DFEAttribTest {
modulepar boolean DFEAttribTest_verbose := false;
#define verbose DFEAttribTest_verbose
#include "../macros.ttcnin"

type component DFEA {}

/******** boolean *********/

type record dfeabool {
  boolean b
}
with {
  variant (b) "defaultForEmpty as 'true'";
  variant (b) "attribute"
}

DECLARE_EXER_ENCODERS(dfeabool, dfeb);

const dfeabool yea := { true }
const universal charstring estr_yea :=
"<dfeabool b='true'/>\n\n";
const universal charstring estr_yea_omit :=
"<dfeabool />\n\n";

const dfeabool nay := { false }
const universal charstring estr_nay :=
"<dfeabool b='false'/>\n\n";

testcase encode_dfeabool() runs on DFEA
{
  CHECK_METHOD(exer_enc_dfeb, yea, estr_yea);
  CHECK_METHOD(exer_enc_dfeb, nay, estr_nay);
}

testcase decode_dfeabool() runs on DFEA
{
  CHECK_DECODE(exer_dec_dfeb, estr_yea, dfeabool, yea);
  CHECK_DECODE(exer_dec_dfeb, estr_yea_omit, dfeabool, yea);
  CHECK_DECODE(exer_dec_dfeb, estr_nay, dfeabool, nay);
}

/******** charstring *********/

type record dfecs {
  charstring cs
}
with {
  variant (cs) "defaultForEmpty as 'supercalifragilistic'"; // expialidocious
  variant (cs) "attribute"
}

DECLARE_EXER_ENCODERS(dfecs, dfecs);

const dfecs expi  := { "expialidocious" }
const universal charstring estr_expi :=
"<dfecs cs='expialidocious'/>\n\n"

const dfecs super := { "supercalifragilistic" }
const universal charstring estr_super :=
"<dfecs cs='supercalifragilistic'/>\n\n"
const universal charstring estr_super0 :=
"<dfecs/>"

testcase encode_dfecs() runs on DFEA
{
  CHECK_METHOD(exer_enc_dfecs, expi , estr_expi);
  CHECK_METHOD(exer_enc_dfecs, super, estr_super);
}

testcase decode_dfecs() runs on DFEA
{
  CHECK_DECODE(exer_dec_dfecs, estr_expi  , dfecs, expi);
  CHECK_DECODE(exer_dec_dfecs, estr_super , dfecs, super);
  CHECK_DECODE(exer_dec_dfecs, estr_super0, dfecs, super);
}

/********** float **********/

type record dfeaf {
  float f
}
with {
  variant (f) "defaultForEmpty as '2.71828'";
  variant (f) "attribute"
}

DECLARE_EXER_ENCODERS(dfeaf, dfeaf);

const dfeaf pi := { 3.141592 } // close enough
const universal charstring estr_pi :=
"<dfeaf f='3.141592'/>\n\n";

const dfeaf ee := { 2.71828 }
const universal charstring estr_ee :=
"<dfeaf f='2.718280'/>\n\n";
const universal charstring estr_ee0 :=
"<dfeaf/>\n\n";

testcase encode_dfeaf() runs on DFEA
{
  CHECK_METHOD(exer_enc_dfeaf, pi, estr_pi);
  CHECK_METHOD(exer_enc_dfeaf, ee, estr_ee);
}

testcase decode_dfeaf() runs on DFEA
{
  CHECK_DECODE(exer_dec_dfeaf, estr_pi , dfeaf, pi);
  CHECK_DECODE(exer_dec_dfeaf, estr_ee , dfeaf, ee);
  CHECK_DECODE(exer_dec_dfeaf, estr_ee0, dfeaf, ee);
}

/********** integer **********/

type record dfeaint {
  integer i
}
with {
  variant (i) "defaultForEmpty as '147'";
  variant (i) "attribute"
}

DECLARE_EXER_ENCODERS(dfeaint, dfei);

const dfeaint fourty_two := { 42 };
const universal charstring estr_42 :=
"<dfeaint i='42'/>\n\n";

const dfeaint one_four_seven := { 147 };
const universal charstring estr_147 :=
"<dfeaint i='147'/>\n\n";
const universal charstring estr_147o :=
"<dfeaint/>";

testcase encode_dfei() runs on DFEA
{
  CHECK_METHOD(exer_enc_dfei, fourty_two, estr_42);
  CHECK_METHOD(exer_enc_dfei, one_four_seven, estr_147);
}

testcase decode_dfei() runs on DFEA
{
  CHECK_DECODE(exer_dec_dfei, estr_42  , dfeaint, fourty_two);
  CHECK_DECODE(exer_dec_dfei, estr_147 , dfeaint, one_four_seven);
  CHECK_DECODE(exer_dec_dfei, estr_147o, dfeaint, one_four_seven);
}

/********** uni-str **********/

type record dfeus {
  universal charstring us
}
with {
  variant (us) "defaultForEmpty as 'Supercalifragilistic'"; // expialidocious
  variant (us) "attribute"
}

DECLARE_EXER_ENCODERS(dfeus, dfeus);

const dfeus uexpi  := { "Expialidocious" }
const universal charstring eustr_expi :=
"<dfeus us='Expialidocious'/>\n\n"

const dfeus usuper := { "Supercalifragilistic" }
const universal charstring eustr_super :=
"<dfeus us='Supercalifragilistic'/>\n\n"
const universal charstring eustr_super0 :=
"<dfeus/>"

testcase encode_dfeus() runs on DFEA
{
  CHECK_METHOD(exer_enc_dfeus, uexpi , eustr_expi);
  CHECK_METHOD(exer_enc_dfeus, usuper, eustr_super);
}

testcase decode_dfeus() runs on DFEA
{
  CHECK_DECODE(exer_dec_dfeus, eustr_expi  , dfeus, uexpi);
  CHECK_DECODE(exer_dec_dfeus, eustr_super , dfeus, usuper);
  CHECK_DECODE(exer_dec_dfeus, eustr_super0, dfeus, usuper);
}


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

testcase stopper() runs on DFEA // never in control
{
  NOT_YET
}

control {
  execute(encode_dfeabool());
  execute(decode_dfeabool());

  execute(encode_dfecs());
  execute(decode_dfecs());

  execute(encode_dfeaf());
  execute(decode_dfeaf());

  execute(encode_dfeus());
  execute(decode_dfeus());

}

}
with {
encode "XML";
}