[deliverable/titan.core.git] / regression_test / json / Testcases.ttcn

/******************************************************************************
 * Copyright (c) 2000-2014 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 Testcases {

import from Functions all;
import from Types all;
import from JsonData language "ASN.1" all;

modulepar R tsp_r := {
  i:= 1,
  cs:="two",
  b:=true,
  d:=Monday
};

modulepar charstring tsp_cs_long := "123456789123456789123456789 abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz ;""'\\/\n\r\t\f\b.,<>?|:][{}=-+!@#$%^&*()";


const octetstring c_BOM_UTF8 :='EFBBBF'O; 

const integer c_i :=18

const R c_r := {
  i:= 1,
  cs:="two",
  b:=true,
  d:= Monday
};

const charstring qm := "\""; //quotation mark
const octetstring qmo :='22'O;
const octetstring commao := '2C'O;
const universal charstring c_arvizturo := char(0,0,0,193)&"rv"&char(0,0,0,237)&"zt"&char(0,0,1,113)&"r"&char(0,0,1,81) & "t" & char(0,0,0,252)&"k"&char(0,0,0,246)&"rfr"&char(0,0,0,243)&"g"&char(0,0,0,233)&"p";
const charstring c_cs_long := "123456789123456789123456789 abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz ;"
const charstring c_cs_escapes := "'\\/\n\r\t\f\b.,<>?|:][{}=-+!@#$%^&*()";


//=========================================================================
// Testcases
//=========================================================================
  
testcase tc_integer_pos() runs on MTC{
  var integer x1 := 18;
  f_check_encoding(encoded:= f_enc_int(x1), expected := '3138'O)
  f_bool2verdict(x1==f_dec_int(f_enc_int(x1)));
}

testcase tc_integer_0() runs on MTC{
  var integer x1 := 0;
  f_check_encoding(encoded:= f_enc_int(x1), expected := '30'O)
  f_bool2verdict(x1==f_dec_int(f_enc_int(x1)));
}

testcase tc_integer_neg() runs on MTC{
  var integer x := -917805;

  f_check_encoding(encoded:= f_enc_int(x), expected := char2oct(int2str(x))) ;
  f_bool2verdict(x==f_dec_int(f_enc_int(x)));
}

testcase tc_integer_bigpos() runs on MTC{
  var integer x1 := 123456789123456789123456789;
  f_check_encoding(encoded:= f_enc_int(x1), expected := '313233343536373839313233343536373839313233343536373839'O)
  f_bool2verdict(x1==f_dec_int(f_enc_int(x1)));
}

testcase tc_integer_expression1() runs on MTC{
  var integer x := 2;
  var octetstring os:= f_enc_int( 6*x )
  f_check_encoding(encoded:= os, expected := '3132'O)
  f_bool2verdict(12==f_dec_int(os));
}

testcase tc_integer_const() runs on MTC{

  var octetstring os:= f_enc_int( c_i )
  f_check_encoding(encoded:= os, expected := '3138'O)
  f_bool2verdict(c_i==f_dec_int(os));
}

testcase tc_integer_imported() runs on MTC{
  var octetstring os:= f_enc_int( c_imported_i )
  f_check_encoding(encoded:= os, expected := '3131'O)
  f_bool2verdict(c_imported_i==f_dec_int(os));
}

testcase tc_boolean_true() runs on MTC{
  var boolean x := true;
  var octetstring os:= f_enc_bool( x )
  f_check_encoding(encoded:= os, expected := char2oct("true"));
  f_bool2verdict(x==f_dec_bool(os));
}

testcase tc_boolean_false() runs on MTC{
  var boolean x := false;
  var octetstring os:= f_enc_bool( x )
  f_check_encoding(encoded:= os, expected := char2oct("false"));
  f_bool2verdict(x==f_dec_bool(os));
}

testcase tc_charstring_ascii_basic() runs on MTC{
  var charstring cs := "everything or nothing"
  var octetstring os:= f_enc_cs( cs )
  f_check_encoding(encoded:= os, expected := char2oct(qm & cs & qm));
  f_bool2verdict(cs==f_dec_cs(os));
}

testcase tc_charstring_ascii_basic_long() runs on MTC{
  var charstring cs := c_cs_long;
  var octetstring os:= f_enc_cs( cs )
  f_check_encoding(encoded:= os, expected := char2oct(qm & cs & qm));
  f_bool2verdict(cs==f_dec_cs(os));
}

testcase tc_charstring_ascii_basic_long_const() runs on MTC{
  var charstring cs := c_cs_long;
  var octetstring os:= f_enc_cs( c_cs_long )
  f_check_encoding(encoded:= os, expected := char2oct(qm & cs & qm));
  f_bool2verdict( cs ==f_dec_cs(os));
}

testcase tc_charstring_ascii_basic_punctuation() runs on MTC{
  var charstring cs := ".,<>?|:][{}=-+!@#$%^&*()";
  var octetstring os:= f_enc_cs( cs )
  f_check_encoding(encoded:= os, expected := char2oct(qm & cs & qm));
  f_bool2verdict(cs ==f_dec_cs(os));
}


testcase tc_charstring_ascii_basic_escapes() runs on MTC{
  var RoCS cs := {
    "\\","/","\n",
    "\r","\t","\f","\b"
  };
  var RoOS os_expected := {
    '225C5C22'O, '222F22'O,'225C6E22'O,
    '225C7222'O,'225C7422'O,'225C6622'O, '225C6222'O
  };
  var integer len:=lengthof(cs);

  for(var integer i:=0;i<len;i:=i+1) {
    var octetstring os:= f_enc_cs( cs[i] )
    f_check_encoding(encoded:= os, expected := os_expected[i]);
    f_bool2verdict(cs[i] ==f_dec_cs(os_expected[i]));
  }
}

testcase tc_charstring_ascii_extended1() runs on MTC{
  var charstring cs := "Vire au Vert l"&char(0,0,0,224)&"!";
  var octetstring os:= f_enc_cs( cs )
  f_check_encoding(encoded:= os, expected := char2oct(qm & cs & qm));
  @try{
    f_bool2verdict(cs==f_dec_cs(os));
    setverdict(fail,"error expected")
  } 
  @catch(err_msg) {
    setverdict(pass,"expected error, ok")
  }

}

testcase tc_ucharstring_ascii_extended1_xer() runs on MTC{
  var universal charstring ucs := "Vire au Vert l" & char(0,0,0,224)&"!";
  var octetstring os:= f_enc_ucs_x( ucs )
  log( "Octetstring:" , os);

  @try{
    f_bool2verdict(ucs==f_dec_ucs_x(os));
    setverdict(pass,ucs," == ", f_dec_ucs_x(os) );
  } 
  @catch(err_msg) {
    setverdict(fail,"unexpected error, nok")
  }
}


//========== Universal Charstring =================


testcase tc_ucharstring_ascii_basic_long() runs on MTC{
  var universal charstring ucs := c_cs_long;
  var octetstring os:= f_enc_ucs( ucs )
  f_check_encoding(encoded:= os, expected := remove_bom(unichar2oct( qm & ucs & qm, "UTF-8")));
  f_bool2verdict(ucs==f_dec_ucs(os));
}

testcase tc_ucharstring_ascii_basic_escapes() runs on MTC{
  var RoUCS cs := {
    "\\","/","\n",
    "\r","\t","\f","\b"
  };
  var RoOS os_expected := {
    '225C5C22'O, '222F22'O,'225C6E22'O,
    '225C7222'O,'225C7422'O,'225C6622'O, '225C6222'O
  };
  var integer len:=lengthof(cs);

  for(var integer i:=0;i<len;i:=i+1) {
    var octetstring os:= f_enc_ucs( cs[i] )
    f_check_encoding(encoded:= os, expected := os_expected[i]);
    f_bool2verdict(cs[i] ==f_dec_ucs(os_expected[i]));
  }
}

testcase tc_ucharstring_ascii_extended1() runs on MTC{
  var universal charstring ucs := "Vire au Vert l" & char(0,0,0,224)&"!";
  var octetstring os:= f_enc_ucs( ucs )
  f_check_encoding(encoded:= os, expected := remove_bom(unichar2oct( qm & ucs & qm, "UTF-8")));
  f_bool2verdict(ucs==f_dec_ucs(os));
}

testcase tc_ucharstring_ascii_extended2() runs on MTC{
  //var universal charstring ucs := "Árvíztűrő tükörfúrógép";'
  var universal charstring ucs :="Ár";
  var octetstring os:= f_enc_ucs( ucs )
  f_check_encoding(encoded:= os, expected := remove_bom(unichar2oct( qm & ucs & qm, "UTF-8")));
  f_bool2verdict(ucs==f_dec_ucs(os));
}

testcase tc_ucharstring_ascii_extended3() runs on MTC{
  var universal charstring ucs := c_arvizturo;
  log("ucs:",ucs);
  var octetstring os:= f_enc_ucs( ucs )
  f_check_encoding(encoded:= os, expected := remove_bom(unichar2oct( qm & ucs & qm, "UTF-8")));
  f_bool2verdict(ucs==f_dec_ucs(os));
}

testcase tc_ucharstring_higherplanes() runs on MTC{
  var RoUCS us := { 
    char(0,1,0,0) & char(0,1,0,175) & char(0,1,255,255),
    char(0,2,0,0) & char(0,2,0,175) & char(0,2,255,255),
    char(0,3,0,0) & char(0,3,0,175) & char(0,3,255,255),
    char(0,15,0,0)& char(0,15,0,175)& char(0,15,255,255),
    char(0,16,0,0)& char(0,16,0,175)& char(0,16,255,255),
    char(0,16,0,0) & char(0,0,0,1) & " "
  };
  var octetstring os;
  var integer len:=lengthof(us);

  for(var integer i:=0;i<len;i:=i+1) {
    os:= f_enc_ucs( us[i] );
    f_check_encoding(encoded:= os, expected := remove_bom(unichar2oct( qm & us[i] & qm, "UTF-8")));
    f_bool2verdict(us[i]==f_dec_ucs(os));
  }
}

//========= Octetstring ===================

testcase tc_octetstring() runs on MTC{
  var octetstring o := '51AD7F32112CC89D'O;
  var octetstring os:= f_enc_os( o )
  f_check_encoding(encoded:= os, expected := '223531414437463332313132434338394422'O);
  f_check_encoding(encoded:= os, expected := qmo & char2oct(oct2str(o)) & qmo);
  f_bool2verdict(o == f_dec_os(os));
}


//========= Hexstring ===================

testcase tc_hexstring() runs on MTC{
  var hexstring h := '51AD7F32112CC89D1778DE213A345BA'H;
  log(hex2str(h));
  var octetstring os:= f_enc_hex( h );
  
  f_check_encoding(encoded:= os, expected := '223531414437463332313132434338394431373738444532313341333435424122'O);
  f_check_encoding(encoded:= os, expected := qmo & char2oct(hex2str(h)) & qmo);
  f_bool2verdict(h == f_dec_hex(os));
}


//========= Bitstring ===================
testcase tc_bitstring() runs on MTC{
  var bitstring bs := '1101001101111011'B;
  var octetstring os:= f_enc_bit(bs);
  f_check_encoding(encoded:= os, expected := qmo & char2oct(bit2str(bs)) & qmo);
  f_bool2verdict(bs == f_dec_bit(os));
}

//========= Verdicttype  ===================
testcase tc_verdicttype() runs on MTC{
  var RoV vt := { none,  inconc,  pass,   fail,   error};
  var RoCS cs :={"none","inconc","pass", "fail", "error"}
  //var verdicttype vt := inconc;
  var octetstring os;
  var integer len :=lengthof(vt)
  for(var integer i:=0;i<len;i:=i+1) {
   os:= f_enc_vt(vt[i]); 
   f_check_encoding(encoded:= os, expected := qmo & char2oct(cs[i]) & qmo);
   f_bool2verdict(vt[i] == f_dec_vt(f_enc_vt(vt[i])));
  }
   
}

//========= Float ===================
testcase tc_float() runs on MTC{
  var RoF f := {  58.1165,  19.6695e16,  not_a_number, infinity, -infinity };
  var RoCS cs := {"58.116500","1.966950e+17","\"not_a_number\"", "\"infinity\"", "\"-infinity\""}
  var octetstring os;
  var integer len :=lengthof(f)
  
  for(var integer i:=0;i<len;i:=i+1) {
   os:= f_enc_f(f[i]); 
   f_check_encoding(encoded:= os, expected := char2oct(cs[i]) );
   log(f_dec_f(f_enc_f(f[i])))
   f_bool2verdict( f[i] == f_dec_f(f_enc_f(f[i])) ) ;
  }
  
}


//============ enum ======================

testcase tc_enum() runs on MTC{
  var Days day := Monday;
  var octetstring os:= char2oct("Monday");
  f_check_encoding(encoded:= os, expected := char2oct("Monday") );
  f_bool2verdict(day ==f_dec_days(f_enc_days(day))  )
}

//===== Record =======

testcase tc_record() runs on MTC{
  var R r := {
    i:= 1,
    cs:="two",
    b:=true,
    d:=Monday
  };
  var octetstring os := char2oct("{\"i\":1,\"cs\":\"two\",\"b\":true,\"d\":\"Monday\"}");
  f_check_encoding(encoded:= f_enc_R(r), expected := os)
  f_bool2verdict(match(f_dec_R(f_enc_R(r)), r));
}

testcase tc_record_const() runs on MTC{
  var octetstring os := char2oct("{\"i\":1,\"cs\":\"two\",\"b\":true,\"d\":\"Monday\"}");
  f_check_encoding(encoded:= f_enc_R(c_r), expected := os)
  f_bool2verdict(match(f_dec_R(f_enc_R(c_r)), c_r));
}

testcase tc_record_modulepar() runs on MTC{
  var octetstring os := char2oct("{\"i\":1,\"cs\":\"two\",\"b\":true,\"d\":\"Monday\"}");
  f_check_encoding(encoded:= f_enc_R(tsp_r), expected := os)
  f_bool2verdict(match(f_dec_R(f_enc_R(tsp_r)), tsp_r));
}

testcase tc_record_empty() runs on MTC{
  var EmptyRec r := { };
  var octetstring os := char2oct("{}");
  f_check_encoding(encoded:= f_enc_ER(r), expected := os)
  f_bool2verdict(match(f_dec_ER(f_enc_ER(r)), r));
}


//====== Record of===============

//ROI
testcase tc_recordofinteger_empty() runs on MTC{
  var RoI r:={}
  var octetstring os := char2oct("[]");
  f_check_encoding(encoded:= f_enc_roi(r), expected := os)
  f_bool2verdict(match(f_dec_roi(f_enc_roi(r)), r));
}

testcase tc_recordofinteger_short() runs on MTC{
  var RoI r:= { 1, 4, 5, 7, 6, 6, 4, 0 , -1 };
  var octetstring os := char2oct("[1,4,5,7,6,6,4,0,-1]");
  f_check_encoding(encoded:= f_enc_roi(r), expected := os)
  f_bool2verdict(match(f_dec_roi(f_enc_roi(r)), r));
}

testcase tc_recordofinteger_long() runs on MTC{
  var RoI r:= {0};
  var octetstring os := char2oct("[0");
  //init:
  
  for(var integer i:=1; i<50; i:=i+1) {
    r[i]:=i;
    os := os & commao & char2oct(int2str(i));
  }
  os := os & char2oct("]")
  log(r);
  log(os)
  //test:
  f_check_encoding(encoded:= f_enc_roi(r), expected := os)
  f_bool2verdict(match(f_dec_roi(f_enc_roi(r)), r));
}

//RoF
testcase tc_recordoffloat_empty() runs on MTC{
  var RoF r:={}
  var octetstring os := char2oct("[]");
  f_check_encoding(encoded:= f_enc_rof(r), expected := os)
  f_bool2verdict(match(f_dec_rof(f_enc_rof(r)), r));
}

testcase tc_recordoffloat_short() runs on MTC{
  var RoF r:={1.0, 1.234, 12.345e12, 12.345e-3, infinity}
  var octetstring os := char2oct("[1.000000,1.234000,1.234500e+13,0.012345,\"infinity\"]");
  f_check_encoding(encoded:= f_enc_rof(r), expected := os)
  f_bool2verdict( match(r,f_dec_rof(f_enc_rof(r))));
  log(match(r,f_dec_rof(f_enc_rof(r))));
}

//RoCS
testcase tc_recordofCS_empty() runs on MTC{
  var RoCS r:={}
  var octetstring os := char2oct("[]");
  f_check_encoding(encoded:= f_enc_rocs(r), expected := os)
  f_bool2verdict(match(f_dec_rocs(f_enc_rocs(r)), r));
}

testcase tc_recordofCS_short() runs on MTC{
  var RoCS r:={ "alMa", "","korte","joe@gmail.com"}
  var octetstring os := char2oct("[\"alMa\",\"\",\"korte\",\"joe@gmail.com\"]");
  f_check_encoding(encoded:= f_enc_rocs(r), expected := os)
  f_bool2verdict( match(r,f_dec_rocs(f_enc_rocs(r))));
  log(match(r,f_dec_rocs(f_enc_rocs(r))));
}

//====== Array ==================

testcase tc_array_int() runs on MTC {
  var IntArr r:= { 1, 4, 7 };
  var octetstring os := char2oct("[1,4,7]");
  f_check_encoding(encoded:= f_enc_ints(r), expected := os)
  f_bool2verdict(match(r,f_dec_ints(f_enc_ints(r))));
  log(match(r,f_dec_ints(f_enc_ints(r))));
}

testcase tc_array_float() runs on MTC {
  var FloatArr r:= { 3.14, 2.73, 0.66666 };
  var octetstring os := char2oct("[3.140000,2.730000,0.666660]");
  f_check_encoding(encoded:= f_enc_floats(r), expected := os)
  f_bool2verdict(match(r,f_dec_floats(f_enc_floats(r))));
  log(match(r,f_dec_floats(f_enc_floats(r))));
}

testcase tc_array_str() runs on MTC {
  var StrArr r:= { "red", "blue", "green", "white" };
  var octetstring os := char2oct("[\"red\",\"blue\",\"green\",\"white\"]");
  f_check_encoding(encoded:= f_enc_strs(r), expected := os)
  f_bool2verdict(match(r,f_dec_strs(f_enc_strs(r))));
  log(match(r,f_dec_strs(f_enc_strs(r))));
}

//====== Union ==================
testcase tc_union() runs on MTC{
  var A myunion := { b:= true }
  var octetstring os := char2oct("{\"b\":true}");
  f_check_encoding(encoded:= f_enc_A(myunion), expected := os)
  f_bool2verdict(match(f_dec_A(f_enc_A(myunion)), myunion));
}

testcase tc_union2() runs on MTC{
  var A myunion := { f:= infinity }
  var octetstring os := char2oct("{\"f\":\"infinity\"}");
  f_check_encoding(encoded:= f_enc_A(myunion), expected := os)
  f_bool2verdict(match(f_dec_A(f_enc_A(myunion)), myunion));
}

testcase tc_union_false() runs on MTC{
  var A myunion := { b:= true }
  var octetstring os := char2oct("{\"b\":true}");
  f_check_encoding(encoded:= f_enc_A(myunion), expected := os)
  @try{ 
    var A retval := f_dec_A('ABBA'O);
    setverdict(fail,"error expected, not received");
  } 
  @catch( err_msg){
    log(err_msg);
    setverdict(pass,"expected error received")
  }
}

//====== ASN.1 types ==================
// SEQUENCE OF INTEGER
testcase tc_asn_seqof() runs on MTC {
  var octetstring os := char2oct(c_ints_str);
  f_check_encoding(encoded:= f_enc_seqofint(c_ints), expected := os)
  f_bool2verdict(match(f_dec_seqofint(os), c_ints));
}

// SEQUENCE
testcase tc_asn_seq() runs on MTC {
  var octetstring os := char2oct(c_product_str);
  f_check_encoding(encoded:= f_enc_seqprod(c_product), expected := os)
  f_bool2verdict(match(f_dec_seqprod(os), c_product));
}

// CHOICE
testcase tc_asn_choice() runs on MTC {
  var octetstring os := char2oct(c_number_str);
  f_check_encoding(encoded:= f_enc_number(c_number), expected := os)
  f_bool2verdict(match(f_dec_number(os), c_number));
}

// SEQUENCE OF CHOICE
testcase tc_asn_strings() runs on MTC {
  var octetstring os := char2oct(c_strings_str);
  f_check_encoding(encoded:= f_enc_strings(c_strings), expected := os)
  f_bool2verdict(match(f_dec_strings(os), c_strings));
}

// SET containing a SEQUENCE, a SET OF CHOICE and a SEQUENCE OF CHOICE
testcase tc_asn_complex() runs on MTC {
  var octetstring os := char2oct(c_set_val_str);
  f_check_encoding(encoded:= f_enc_complex(c_set_val), expected := os)
  f_bool2verdict(match(f_dec_complex(os), c_set_val));
}

// ====== Special ASN.1 types ======
// record containing an open type and a possible NULL value
testcase tc_asn_open_type_and_null() runs on MTC {
  var HasPardType x := {
    pard := {
      id := 0,
      priority := low,
      val := { iNTEGER := 19 }
    },
    buul := true,
    price := { invaluable := NULL }
  };
  var octetstring os := char2oct("{\"pard\":{\"id\":0,\"priority\":\"low\",\"val\":{\"iNTEGER\":19}},\"buul\":true,\"price\":{\"invaluable\":null}}");
  f_check_encoding(encoded := f_enc_hpt(x), expected := os);
  f_bool2verdict(match(f_dec_hpt(os), x));
}

// SEQUENCE containing an object identifier and an ANY type
testcase tc_asn_objid_and_any() runs on MTC {
  var octetstring os := char2oct(c_obj_str);
  f_check_encoding(encoded:= f_enc_obj(c_obj), expected := os);
  f_bool2verdict(match(f_dec_obj(os), c_obj));
}

testcase tc_asn_optional_null() runs on MTC {
  var octetstring os := char2oct(c_null_str);
  f_check_encoding(encoded:= f_enc_null(c_null), expected := os);
  f_bool2verdict(match(f_dec_null(os), c_null));
  os := char2oct(c_not_null_str);
  f_check_encoding(encoded:= f_enc_null(c_not_null), expected := os);
  f_bool2verdict(match(f_dec_null(os), c_not_null));
}

//=========================================================================
// Control
//=========================================================================
control {

  execute(tc_integer_pos());
  execute(tc_integer_0());
  execute(tc_integer_neg());
  execute(tc_integer_bigpos());
  execute(tc_integer_expression1());
  execute(tc_integer_const());
  execute(tc_integer_imported());
  execute(tc_boolean_true());
  execute(tc_boolean_false());
  execute(tc_charstring_ascii_basic());
  execute(tc_charstring_ascii_basic_long());
  execute(tc_charstring_ascii_basic_long_const());
  execute(tc_charstring_ascii_basic_punctuation());
  execute(tc_charstring_ascii_basic_escapes());
  execute(tc_charstring_ascii_extended1());
  execute(tc_charstring_ascii_basic_escapes());

  execute(tc_ucharstring_ascii_extended1_xer());
  execute(tc_ucharstring_ascii_extended1());
  execute(tc_ucharstring_ascii_extended2());
  execute(tc_ucharstring_ascii_extended3());
  execute(tc_ucharstring_higherplanes());
  execute(tc_octetstring());
  execute(tc_hexstring());
  execute(tc_bitstring());
  execute(tc_verdicttype());
  execute(tc_float());
  execute(tc_record());
  execute(tc_record_const());
  execute(tc_record_modulepar());
  execute(tc_record_empty());
  execute(tc_recordofinteger_empty());
  execute(tc_recordofinteger_short());
  execute(tc_recordoffloat_empty());
  execute(tc_recordoffloat_short());
  execute(tc_recordofCS_empty());
  execute(tc_recordofCS_short());
  execute(tc_array_int());
  execute(tc_array_float());
  execute(tc_array_str());
  execute(tc_union());
  execute(tc_union2());
  execute(tc_union_false());

  execute(tc_asn_seqof());
  execute(tc_asn_seq());
  execute(tc_asn_choice());
  execute(tc_asn_strings());
  execute(tc_asn_complex());

  execute(tc_asn_open_type_and_null());
  execute(tc_asn_objid_and_any());
  execute(tc_asn_optional_null());
}


}