| 3f84031e |
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 | } |
projects / deliverable / titan.core.git / blame