regression_test/negativeTest/NegTest_JSON.ttcn

   1 /******************************************************************************
   2  * Copyright (c) 2000-2015 Ericsson Telecom AB
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  ******************************************************************************/
   8
   9 // This module tests the 'negative testing' feature of the JSON encoder.
  10 module NegTest_JSON {
  11
  12 /****************** Types ******************/
  13 type record of integer IntList;
  14
  15 type record of IntList IntListList;
  16
  17 type record Rec {
  18   integer num,
  19   charstring str optional
  20 }
  21
  22 type set Set {
  23   IntList list,
  24   Rec rec optional,
  25   boolean b
  26 }
  27
  28 type union Uni {
  29   integer i,
  30   octetstring os,
  31   IntList list
  32 }
  33
  34 type union Uni2 {
  35   integer i,
  36   octetstring os,
  37   IntList list
  38 }
  39 with {
  40   variant "JSON: as value";
  41 }
  42
  43 type component CT {}
  44
  45 /************ Encoding functions ************/
  46 external function f_enc_il(in IntList x) return octetstring
  47   with { extension "prototype(convert) encode(JSON)" }
  48
  49 external function f_enc_ill(in IntListList x) return octetstring
  50   with { extension "prototype(convert) encode(JSON)" }
  51
  52 external function f_enc_r(in Rec x) return octetstring
  53   with { extension "prototype(convert) encode(JSON)" }
  54
  55 external function f_enc_s(in Set x) return octetstring
  56   with { extension "prototype(convert) encode(JSON)" }
  57
  58 external function f_enc_u(in Uni x) return octetstring
  59   with { extension "prototype(convert) encode(JSON)" }
  60
  61 external function f_enc_u2(in Uni2 x) return octetstring
  62   with { extension "prototype(convert) encode(JSON)" }
  63
  64 /************* Erroneous values *************/
  65 const IntList il1 := { 0, 1, 2, 3 } with { erroneous([2]) "before := omit all" };
  66 const IntList il2 := { 0, 1, 2, 3 } with { erroneous([2]) "after := omit all" };
  67 const IntList il3 := { 4, 5, 6 } with { erroneous([1]) "before := boolean:false" };
  68 const IntList il4 := { 4, 5, 6 } with { erroneous([1]) "after := boolean:false" };
  69 const IntList il5 := { 4, 5, 6 } with { erroneous([1]) "value := boolean:false" };
  70 const IntList il6 := { 7, 8, 9 } with { erroneous([0]) "before(raw) := '616263'O" };
  71 const IntList il7 := { 7, 8, 9 } with { erroneous([0]) "after(raw) := '616263'O" };
  72 const IntList il8 := { 7, 8, 9 } with { erroneous([0]) "value(raw) := '616263'O" };
  73
  74 const IntListList ill1 := { il1, il3, il5, il7 };
  75 const IntListList ill2 := { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8 } } with { erroneous([1]) "before := float:3.5"; erroneous([2][2]) "before := omit all" };
  76
  77 const Rec r1 := { num := 10, str := "hello" } with { erroneous(num) "before := true" };
  78 const Rec r2 := { num := 10, str := "hello" } with { erroneous(num) "after := true" };
  79 const Rec r3 := { num := 10, str := "hello" } with { erroneous(num) "value := true" };
  80 const Rec r4 := { num := 10, str := "hello" } with { erroneous(str) "value := omit" };
  81 const Rec r5 := { num := 10, str := "hello" } with { erroneous(num) "before(raw) := \"abc\"" };
  82 const Rec r6 := { num := 10, str := "hello" } with { erroneous(num) "after(raw) := \"abc\"" };
  83 const Rec r7 := { num := 10, str := "hello" } with { erroneous(num) "value(raw) := \"abc\"" };
  84
  85 const Set s1 := { list := il4, rec := r2, b := false } with { erroneous(rec) "before := omit all" };
  86 const Set s2 := { list := il4, rec := r2, b := false } with { erroneous(rec) "after := omit all" };
  87 const Set s3 := { list := { 1, 3, 5, 7 }, rec := { num := 2, str := "abc" }, b := true } with { erroneous(list[2]) "after := charstring:""str"""; erroneous(rec.str) "value(raw) := \"abc\"" };
  88
  89 const Uni u1 := { i := -6 } with { erroneous(i) "value := \"-6\"" };
  90 const Uni u2 := { i := -6 } with { erroneous(i) "value := omit" };
  91 const Uni u3 := { i := -6 } with { erroneous(i) "value(raw) := universal charstring:\"abc\"" };
  92 const Uni u4 := { os := '1234'O } with { erroneous(i) "value := \"-6\"" }; // non-selected field is erroneous
  93 const Uni u5 := { list := { 0, 3, 6 } } with { erroneous(list[2]) "value := \"6\"" };
  94
  95 const Uni2 u6 := { i := -6 } with { erroneous(i) "value := \"-6\"" };
  96 const Uni2 u7 := { i := -6 } with { erroneous(i) "value := omit" };
  97 const Uni2 u8 := { i := -6 } with { erroneous(i) "value(raw) := \"abc\" & char(0,0,1,117)" };
  98 const Uni2 u9 := { list := { 0, 3, 6 } } with { erroneous(list[2]) "value := \"6\"" };
  99
 100 /******** Test cases for record-ofs ********/
 101 testcase tc_record_of_omit_before() runs on CT {
 102   var octetstring res := f_enc_il(il1);
 103   if (char2oct("[2,3]") == res) { setverdict(pass); }
 104   else { setverdict(fail, res); }
 105 }
 106
 107 testcase tc_record_of_omit_after() runs on CT {
 108   var octetstring res := f_enc_il(il2);
 109   if (char2oct("[0,1,2]") == res) { setverdict(pass); }
 110   else { setverdict(fail, res); }
 111 }
 112
 113 testcase tc_record_of_extra_before() runs on CT {
 114   var octetstring res := f_enc_il(il3);
 115   if (char2oct("[4,false,5,6]") == res) { setverdict(pass); }
 116   else { setverdict(fail, res); }
 117 }
 118
 119 testcase tc_record_of_extra_after() runs on CT {
 120   var octetstring res := f_enc_il(il4);
 121   if (char2oct("[4,5,false,6]") == res) { setverdict(pass); }
 122   else { setverdict(fail, res); }
 123 }
 124
 125 testcase tc_record_of_other_value() runs on CT {
 126   var octetstring res := f_enc_il(il5);
 127   if (char2oct("[4,false,6]") == res) { setverdict(pass); }
 128   else { setverdict(fail, res); }
 129 }
 130
 131 testcase tc_record_of_raw_before() runs on CT {
 132   var octetstring res := f_enc_il(il6);
 133   if (char2oct("[abc7,8,9]") == res) { setverdict(pass); }
 134   else { setverdict(fail, res); }
 135 }
 136
 137 testcase tc_record_of_raw_after() runs on CT {
 138   var octetstring res := f_enc_il(il7);
 139   if (char2oct("[7abc,8,9]") == res) { setverdict(pass); }
 140   else { setverdict(fail, res); }
 141 }
 142
 143 testcase tc_record_of_raw_value() runs on CT {
 144   var octetstring res := f_enc_il(il8);
 145   if (char2oct("[abc8,9]") == res) { setverdict(pass); }
 146   else { setverdict(fail, res); }
 147 }
 148
 149 testcase tc_record_of_embedded_values() runs on CT {
 150   var octetstring res := f_enc_ill(ill1);
 151   if (char2oct("[[2,3],[4,false,5,6],[4,false,6],[7abc,8,9]]") == res) { setverdict(pass); }
 152   else { setverdict(fail, res); }
 153 }
 154
 155 testcase tc_record_of_erroneous_in_elements() runs on CT {
 156   var octetstring res := f_enc_ill(ill2);
 157   if (char2oct("[[1,2,3],3.500000,[4,5],[8]]") == res) { setverdict(pass); }
 158   else { setverdict(fail, res); }
 159 }
 160
 161 /***** Test cases for records and sets *****/
 162 testcase tc_record_extra_before() runs on CT {
 163   var octetstring res := f_enc_r(r1);
 164   if (char2oct("{\"BOOLEAN\":true,\"num\":10,\"str\":\"hello\"}") == res) { setverdict(pass); }
 165   else { setverdict(fail, res); }
 166 }
 167
 168 testcase tc_record_extra_after() runs on CT {
 169   var octetstring res := f_enc_r(r2);
 170   if (char2oct("{\"num\":10,\"BOOLEAN\":true,\"str\":\"hello\"}") == res) { setverdict(pass); }
 171   else { setverdict(fail, res); }
 172 }
 173
 174 testcase tc_record_other_value() runs on CT {
 175   var octetstring res := f_enc_r(r3);
 176   if (char2oct("{\"num\":true,\"str\":\"hello\"}") == res) { setverdict(pass); }
 177   else { setverdict(fail, res); }
 178 }
 179
 180 testcase tc_record_omit_value() runs on CT {
 181   var octetstring res := f_enc_r(r4);
 182   if (char2oct("{\"num\":10}") == res) { setverdict(pass); }
 183   else { setverdict(fail, res); }
 184 }
 185
 186 testcase tc_record_raw_before() runs on CT {
 187   var octetstring res := f_enc_r(r5);
 188   if (char2oct("{abc\"num\":10,\"str\":\"hello\"}") == res) { setverdict(pass); }
 189   else { setverdict(fail, res); }
 190 }
 191
 192 testcase tc_record_raw_after() runs on CT {
 193   var octetstring res := f_enc_r(r6);
 194   if (char2oct("{\"num\":10abc,\"str\":\"hello\"}") == res) { setverdict(pass); }
 195   else { setverdict(fail, res); }
 196 }
 197
 198 testcase tc_record_raw_value() runs on CT {
 199   var octetstring res := f_enc_r(r7);
 200   if (char2oct("{abc\"str\":\"hello\"}") == res) { setverdict(pass); }
 201   else { setverdict(fail, res); }
 202 }
 203
 204 testcase tc_set_embedded_values_omit_before() runs on CT {
 205   var octetstring res := f_enc_s(s1);
 206   if (char2oct("{\"rec\":{\"num\":10,\"BOOLEAN\":true,\"str\":\"hello\"},\"b\":false}") == res) { setverdict(pass); }
 207   else { setverdict(fail, res); }
 208 }
 209
 210 testcase tc_set_embedded_values_omit_after() runs on CT {
 211   var octetstring res := f_enc_s(s2);
 212   if (char2oct("{\"list\":[4,5,false,6],\"rec\":{\"num\":10,\"BOOLEAN\":true,\"str\":\"hello\"}}") == res) { setverdict(pass); }
 213   else { setverdict(fail, res); }
 214 }
 215
 216 testcase tc_set_erroneous_in_fields() runs on CT {
 217   var octetstring res := f_enc_s(s3);
 218   if (char2oct("{\"list\":[1,3,5,\"str\",7],\"rec\":{\"num\":2abc},\"b\":true}") == res) { setverdict(pass); }
 219   else { setverdict(fail, res); }
 220 }
 221
 222 /********** Test cases for unions **********/
 223 testcase tc_union_regular_other_value() runs on CT {
 224   var octetstring res := f_enc_u(u1);
 225   if (char2oct("{\"i\":\"-6\"}") == res) { setverdict(pass); }
 226   else { setverdict(fail, res); }
 227 }
 228
 229 testcase tc_union_regular_omit_value() runs on CT {
 230   var octetstring res := f_enc_u(u2);
 231   if (char2oct("{}") == res) { setverdict(pass); }
 232   else { setverdict(fail, res); }
 233 }
 234
 235 testcase tc_union_regular_raw_value() runs on CT {
 236   var octetstring res := f_enc_u(u3);
 237   if (char2oct("{abc}") == res) { setverdict(pass); }
 238   else { setverdict(fail, res); }
 239 }
 240
 241 testcase tc_union_regular_wrong_alternative() runs on CT {
 242   var octetstring res := f_enc_u(u4);
 243   if (char2oct("{\"os\":\"1234\"}") == res) { setverdict(pass); }
 244   else { setverdict(fail, res); }
 245 }
 246
 247 testcase tc_union_regular_alternative_is_erroneous() runs on CT {
 248   var octetstring res := f_enc_u(u5);
 249   if (char2oct("{\"list\":[0,3,\"6\"]}") == res) { setverdict(pass); }
 250   else { setverdict(fail, res); }
 251 }
 252
 253 testcase tc_union_as_value_other_value() runs on CT {
 254   var octetstring res := f_enc_u2(u6);
 255   if (char2oct("\"-6\"") == res) { setverdict(pass); }
 256   else { setverdict(fail, res); }
 257 }
 258
 259 testcase tc_union_as_value_omit_value() runs on CT {
 260   var octetstring res := f_enc_u2(u7);
 261   if (char2oct("") == res) { setverdict(pass); }
 262   else { setverdict(fail, res); }
 263 }
 264
 265 testcase tc_union_as_value_raw_value() runs on CT {
 266   var octetstring res := f_enc_u2(u8);
 267   if (unichar2oct("abc" & char(0,0,1,117), "UTF-8") == res) { setverdict(pass); }
 268   else { setverdict(fail, res); }
 269 }
 270
 271 testcase tc_union_as_value_alternative_is_erroneous() runs on CT {
 272   var octetstring res := f_enc_u2(u9);
 273   if (char2oct("[0,3,\"6\"]") == res) { setverdict(pass); }
 274   else { setverdict(fail, res); }
 275 }
 276
 277 /*************** Control part ***************/
 278 control {
 279   execute(tc_record_of_omit_before());
 280   execute(tc_record_of_omit_after());
 281   execute(tc_record_of_extra_before());
 282   execute(tc_record_of_extra_after());
 283   execute(tc_record_of_other_value());
 284   execute(tc_record_of_raw_before());
 285   execute(tc_record_of_raw_after());
 286   execute(tc_record_of_raw_value());
 287   execute(tc_record_of_embedded_values());
 288   execute(tc_record_of_erroneous_in_elements());
 289   execute(tc_record_extra_before());
 290   execute(tc_record_extra_after());
 291   execute(tc_record_other_value());
 292   execute(tc_record_omit_value());
 293   execute(tc_record_raw_before());
 294   execute(tc_record_raw_after());
 295   execute(tc_record_raw_value());
 296   execute(tc_set_embedded_values_omit_before());
 297   execute(tc_set_embedded_values_omit_after());
 298   execute(tc_set_erroneous_in_fields());
 299   execute(tc_union_regular_other_value());
 300   execute(tc_union_regular_omit_value());
 301   execute(tc_union_regular_raw_value());
 302   execute(tc_union_regular_wrong_alternative());
 303   execute(tc_union_regular_alternative_is_erroneous());
 304   execute(tc_union_as_value_other_value());
 305   execute(tc_union_as_value_omit_value());
 306   execute(tc_union_as_value_raw_value());
 307   execute(tc_union_as_value_alternative_is_erroneous());
 308 }
 309
 310 }
 311 with {
 312   encode "JSON";
 313 }