projects / deliverable / titan.core.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Sync with 5.1.0
[deliverable/titan.core.git] / function_test / Text_EncDec / TEXT_1_TD.fast_script
CommitLineData
970ed795
EL		 1.******************************************************************************
2.* Copyright (c) 2000-2014 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:text.
9:lang eng.
10.*
11:docname.Test Description
12:docno.21/152 91-CRL 113 200/2 Uen
13:rev.A
14:date.2012-06-27
15.*
16:prep.ETH/XZR Ferenc Kovacs (+36 1 439 5511)
17:appr.ETH/XZ (Roland Gecse)
18:checked.ETHPKR
19.*
20:title.Test Description - Text based coding for TTCN-3 Test Executor
21:contents level=3.
22.*---------------------------------------------------------------------*
23:h1.PREREQUISITES AND PREPARATIONS
24.*---------------------------------------------------------------------*
25.*---------------------------------------------------------------------*
26:h2.Scope of the Test Object
27.*---------------------------------------------------------------------*
28:xmp tab=1 nokeep.
29This TD contains unified test cases related to a part of TTCN3 Executor's Text coder function.
30The original test cases can be found in the TEXT_1_TD.script file.
31The reason for the unification was to get a really fast version of the tests.
32
33:exmp.
34
35:p.:us.Revision Information:eus.
36
37:xmp nokeep.
38:us.History:eus.
39
40REV DATE PREPARED CHANGE
41=== ========== ======== ======
42A 2005-01-10 ETHGHASZ New document
43B 2005-10-11 EKRISZA Updated for group support.
44C 2007-03-06 EDMDELI Implicit message encoding
45D 2008-10-01 EFERKOV Big integers
46E 2011-01-24 EKRISZA Restructured to use more efficient script.
47F 2011-10-10 EKRISZA Updated for release.
48A 2011-12-12 EKRISZA Updated for release
49PB1 2012-01-31 ETHBAAT Editorial changes,
50:exmp.
51
52.*---------------------------------------------------------------------*
53:h1.Test environment
54.*---------------------------------------------------------------------*
55.*---------------------------------------------------------------------*
56:h2.Hardware
57.*---------------------------------------------------------------------*
58No specific hardware requirement.
59.*---------------------------------------------------------------------*
60:h2.Software
61.*---------------------------------------------------------------------*
62
63.*---------------------------------------------------------------------*
64:h2.Configuration
65.*---------------------------------------------------------------------*
66
67.*---------------------------------------------------------------------*
68:h2.Installation
69.*---------------------------------------------------------------------*
70.*---------------------------------------------------------------------*
71:h2.Test Tools
72.*---------------------------------------------------------------------*
73.*---------------------------------------------------------------------*
74:h1.REQUIREMENT-BASED TESTS
75.*---------------------------------------------------------------------*
76:xmp tab=0.
77
78<TC - Fixed length encoding>
79
80<STATIC>
81type component TempComp {}
82<TTCN_TC:PURE_EXEC>
83
84type charstring TEXT_PDU_1 with { encode "TEXT"; variant "TEXT_CODING(length=5)"};
85external function enc_TEXT_PDU_1(in TEXT_PDU_1 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
86external function dec_TEXT_PDU_1(in charstring oct) return TEXT_PDU_1 with { extension "prototype(convert) decode(TEXT)" }
87
88testcase TC_Fixed_length_encoding() runs on TempComp {
89 const TEXT_PDU_1 i := "HALI"
90 const charstring o := " HALI"
91 const TEXT_PDU_1 expected_res:=" HALI"
92
93 if ((enc_TEXT_PDU_1(i) == o)and(dec_TEXT_PDU_1(o) == expected_res)) {setverdict(pass);}
94 else {setverdict(fail,"enc_TEXT_PDU_1(i)= ", enc_TEXT_PDU_1(i), "; dec_TEXT_PDU_1(o)= ", dec_TEXT_PDU_1(o));}
95}
96
97
98
99type charstring TEXT_PDU_2 with { encode "TEXT"; variant "TEXT_CODING(convert=lower_case)"};
100external function enc_TEXT_PDU_2(in TEXT_PDU_2 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
101external function dec_TEXT_PDU_2(in charstring oct) return TEXT_PDU_2 with { extension "prototype(convert) decode(TEXT)" }
102
103testcase TC_Convert_string_to_lower_case_during_encoding() runs on TempComp {
104 const TEXT_PDU_2 i := "HALI"
105 const charstring o := "hali"
106 const TEXT_PDU_2 expected_res:="hali"
107
108 if ((enc_TEXT_PDU_2(i) == o)and(dec_TEXT_PDU_2(o) == expected_res)) {setverdict(pass);}
109 else {setverdict(fail,"enc_TEXT_PDU_2(i)= ", enc_TEXT_PDU_2(i), "; dec_TEXT_PDU_2(o)= ", dec_TEXT_PDU_2(o));}
110}
111
112
113
114type charstring TEXT_PDU_3 with { encode "TEXT"; variant "TEXT_CODING(convert=upper_case)"};
115external function enc_TEXT_PDU_3(in TEXT_PDU_3 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
116external function dec_TEXT_PDU_3(in charstring oct) return TEXT_PDU_3 with { extension "prototype(convert) decode(TEXT)" }
117
118testcase TC_Convert_string_to_upper_case_during_encoding() runs on TempComp {
119 const TEXT_PDU_3 i := "hali"
120 const charstring o := "HALI"
121 const TEXT_PDU_3 expected_res:="HALI"
122
123 if ((enc_TEXT_PDU_3(i) == o)and(dec_TEXT_PDU_3(o) == expected_res)) {setverdict(pass);}
124 else {setverdict(fail,"enc_TEXT_PDU_3(i)= ", enc_TEXT_PDU_3(i), "; dec_TEXT_PDU_3(o)= ", dec_TEXT_PDU_3(o));}
125}
126
127
128
129type charstring TEXT_PDU_4 with { encode "TEXT"; variant "TEXT_CODING(convert=lower_case,
130 convert=upper_case)"};
131external function enc_TEXT_PDU_4(in TEXT_PDU_4 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
132external function dec_TEXT_PDU_4(in charstring oct) return TEXT_PDU_4 with { extension "prototype(convert) decode(TEXT)" }
133
134testcase TC_Convert_string_to_lower_case_during_encoding_and_upper_during_decoding() runs on TempComp {
135 const TEXT_PDU_4 i := "HALI"
136 const charstring o := "hali"
137 const TEXT_PDU_4 expected_res:="HALI"
138
139 if ((enc_TEXT_PDU_4(i) == o)and(dec_TEXT_PDU_4(o) == expected_res)) {setverdict(pass);}
140 else {setverdict(fail,"enc_TEXT_PDU_4(i)= ", enc_TEXT_PDU_4(i), "; dec_TEXT_PDU_4(o)= ", dec_TEXT_PDU_4(o));}
141}
142
143
144
145type charstring TEXT_PDU_5 with { encode "TEXT"; variant "TEXT_CODING(convert=upper_case,
146 convert=lower_case)"};
147external function enc_TEXT_PDU_5(in TEXT_PDU_5 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
148external function dec_TEXT_PDU_5(in charstring oct) return TEXT_PDU_5 with { extension "prototype(convert) decode(TEXT)" }
149
150testcase TC_Convert_string_to_upper_case_during_encoding_and_lower_during_decoding() runs on TempComp {
151 const TEXT_PDU_5 i := "hali"
152 const charstring o := "HALI"
153 const TEXT_PDU_5 expected_res:="hali"
154
155 if ((enc_TEXT_PDU_5(i) == o)and(dec_TEXT_PDU_5(o) == expected_res)) {setverdict(pass);}
156 else {setverdict(fail,"enc_TEXT_PDU_5(i)= ", enc_TEXT_PDU_5(i), "; dec_TEXT_PDU_5(o)= ", dec_TEXT_PDU_5(o));}
157}
158
159
160
161type charstring TEXT_PDU_6 with { encode "TEXT"; variant "TEXT_CODING(just=left;length=5)"};
162external function enc_TEXT_PDU_6(in TEXT_PDU_6 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
163external function dec_TEXT_PDU_6(in charstring oct) return TEXT_PDU_6 with { extension "prototype(convert) decode(TEXT)" }
164
165testcase TC_Left_justification() runs on TempComp {
166 const TEXT_PDU_6 i := "hali"
167 const charstring o := "hali "
168 const TEXT_PDU_6 expected_res:="hali "
169
170 if ((enc_TEXT_PDU_6(i) == o)and(dec_TEXT_PDU_6(o) == expected_res)) {setverdict(pass);}
171 else {setverdict(fail,"enc_TEXT_PDU_6(i)= ", enc_TEXT_PDU_6(i), "; dec_TEXT_PDU_6(o)= ", dec_TEXT_PDU_6(o));}
172}
173
174
175
176type charstring TEXT_PDU_7 with { encode "TEXT"; variant "TEXT_CODING(just=center;length=6)"};
177external function enc_TEXT_PDU_7(in TEXT_PDU_7 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
178external function dec_TEXT_PDU_7(in charstring oct) return TEXT_PDU_7 with { extension "prototype(convert) decode(TEXT)" }
179
180testcase TC_Center_justification() runs on TempComp {
181 const TEXT_PDU_7 i := "hali"
182 const charstring o := " hali "
183 const TEXT_PDU_7 expected_res:=" hali "
184
185 if ((enc_TEXT_PDU_7(i) == o)and(dec_TEXT_PDU_7(o) == expected_res)) {setverdict(pass);}
186 else {setverdict(fail,"enc_TEXT_PDU_7(i)= ", enc_TEXT_PDU_7(i), "; dec_TEXT_PDU_7(o)= ", dec_TEXT_PDU_7(o));}
187}
188
189
190
191type charstring TEXT_PDU_8 with { encode "TEXT"; variant "TEXT_CODING(just=right;length=5)"};
192external function enc_TEXT_PDU_8(in TEXT_PDU_8 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
193external function dec_TEXT_PDU_8(in charstring oct) return TEXT_PDU_8 with { extension "prototype(convert) decode(TEXT)" }
194
195testcase TC_Right_justification() runs on TempComp {
196 const TEXT_PDU_8 i := "hali"
197 const charstring o := " hali"
198 const TEXT_PDU_8 expected_res:=" hali"
199
200 if ((enc_TEXT_PDU_8(i) == o)and(dec_TEXT_PDU_8(o) == expected_res)) {setverdict(pass);}
201 else {setverdict(fail,"enc_TEXT_PDU_8(i)= ", enc_TEXT_PDU_8(i), "; dec_TEXT_PDU_8(o)= ", dec_TEXT_PDU_8(o));}
202}
203
204
205
206type charstring TEXT_PDU_9 with { encode "TEXT"; variant "TEXT_CODING(,,'[\d]#(4)[a-e]#(4)')"};
207external function enc_TEXT_PDU_9(in TEXT_PDU_9 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
208external function dec_TEXT_PDU_9(in charstring oct) return TEXT_PDU_9 with { extension "prototype(convert) decode(TEXT)" }
209
210testcase TC_Case_sensitive_selection() runs on TempComp {
211 const TEXT_PDU_9 i := "1234abcd"
212 const TEXT_PDU_9 expected_res:="1234abcd"
213
214 if (dec_TEXT_PDU_9(enc_TEXT_PDU_9(i)) == expected_res) {setverdict(pass);}
215 else {setverdict(fail,"enc_TEXT_PDU_9(i)= ", enc_TEXT_PDU_9(i), "; dec_TEXT_PDU_9(enc_TEXT_PDU_9(i))= ", dec_TEXT_PDU_9(enc_TEXT_PDU_9(i)));}
216}
217
218
219
220type charstring TEXT_PDU_10 with { encode "TEXT"; variant "TEXT_CODING(,convert=lower_case,
221 '[\d]#(4)[a-e]#(4)', case_insensitive)"};
222external function enc_TEXT_PDU_10(in TEXT_PDU_10 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
223external function dec_TEXT_PDU_10(in charstring oct) return TEXT_PDU_10 with { extension "prototype(convert) decode(TEXT)" }
224
225testcase TC_Case_insensitive_selection() runs on TempComp {
226 const TEXT_PDU_10 i := "1234abcd"
227 const TEXT_PDU_10 expected_res:="1234abcd"
228
229 if (dec_TEXT_PDU_10(enc_TEXT_PDU_10(i)) == expected_res) {setverdict(pass);}
230 else {setverdict(fail,"enc_TEXT_PDU_10(i)= ", enc_TEXT_PDU_10(i), "; dec_TEXT_PDU_10(enc_TEXT_PDU_10(i))= ", dec_TEXT_PDU_10(enc_TEXT_PDU_10(i)));}
231}
232
233
234
235type integer TEXT_PDU_11 with { encode "TEXT"; variant "TEXT_CODING(length=5)"};
236external function enc_TEXT_PDU_11(in TEXT_PDU_11 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
237external function dec_TEXT_PDU_11(in charstring oct) return TEXT_PDU_11 with { extension "prototype(convert) decode(TEXT)" }
238
239testcase TC_Fixed_length_integer() runs on TempComp {
240 const TEXT_PDU_11 i := 249
241 const charstring o := " 249"
242 const TEXT_PDU_11 expected_res:= 249
243
244 if ((enc_TEXT_PDU_11(i) == o)and(dec_TEXT_PDU_11(o) == expected_res)) {setverdict(pass);}
245 else {setverdict(fail,"enc_TEXT_PDU_11(i)= ", enc_TEXT_PDU_11(i), "; dec_TEXT_PDU_11(o)= ", dec_TEXT_PDU_11(o));}
246}
247
248
249
250type integer TEXT_PDU_12 with { encode "TEXT"; variant "TEXT_CODING()"};
251external function enc_TEXT_PDU_12(in TEXT_PDU_12 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
252external function dec_TEXT_PDU_12(in charstring oct) return TEXT_PDU_12 with { extension "prototype(convert) decode(TEXT)" }
253
254testcase TC_Variable_length_integer() runs on TempComp {
255 const TEXT_PDU_12 i := 12249
256 const charstring o := "12249"
257 const TEXT_PDU_12 expected_res:= 12249
258
259 if ((enc_TEXT_PDU_12(i) == o)and(dec_TEXT_PDU_12(o) == expected_res)) {setverdict(pass);}
260 else {setverdict(fail,"enc_TEXT_PDU_12(i)= ", enc_TEXT_PDU_12(i), "; dec_TEXT_PDU_12(o)= ", dec_TEXT_PDU_12(o));}
261}
262
263
264
265type integer TEXT_PDU_13 with { encode "TEXT"; variant "TEXT_CODING(length=7)"};
266external function enc_TEXT_PDU_13(in TEXT_PDU_13 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
267external function dec_TEXT_PDU_13(in charstring oct) return TEXT_PDU_13 with { extension "prototype(convert) decode(TEXT)" }
268
269testcase TC_encoding_without_leading_zero() runs on TempComp {
270 const TEXT_PDU_13 i := 12249
271 const charstring o := " 12249"
272 const TEXT_PDU_13 expected_res:= 12249
273
274 if ((enc_TEXT_PDU_13(i) == o)and(dec_TEXT_PDU_13(o) == expected_res)) {setverdict(pass);}
275 else {setverdict(fail,"enc_TEXT_PDU_13(i)= ", enc_TEXT_PDU_13(i), "; dec_TEXT_PDU_13(o)= ", dec_TEXT_PDU_13(o));}
276}
277
278
279
280type integer TEXT_PDU_14 with { encode "TEXT"; variant "TEXT_CODING(leading0=true;length=7)"};
281external function enc_TEXT_PDU_14(in TEXT_PDU_14 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
282external function dec_TEXT_PDU_14(in charstring oct) return TEXT_PDU_14 with { extension "prototype(convert) decode(TEXT)" }
283
284testcase TC_encoding_with_leading_zero() runs on TempComp {
285 const TEXT_PDU_14 i := 12249
286 const charstring o := "0012249"
287 const TEXT_PDU_14 expected_res:= 12249
288
289 if ((enc_TEXT_PDU_14(i) == o)and(dec_TEXT_PDU_14(o) == expected_res)) {setverdict(pass);}
290 else {setverdict(fail,"enc_TEXT_PDU_14(i)= ", enc_TEXT_PDU_14(i), "; dec_TEXT_PDU_14(o)= ", dec_TEXT_PDU_14(o));}
291}
292
293
294
295type integer TEXT_PDU_15 with { encode "TEXT"; variant "TEXT_CODING(leading0=true;length=7)"};
296external function enc_TEXT_PDU_15(in TEXT_PDU_15 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
297external function dec_TEXT_PDU_15(in charstring oct) return TEXT_PDU_15 with { extension "prototype(convert) decode(TEXT)" }
298
299testcase TC_encoding_negativ_integer_with_leading_zero() runs on TempComp {
300 const TEXT_PDU_15 i := -12249
301 const charstring o := "-012249"
302 const TEXT_PDU_15 expected_res:= -12249
303
304 if ((enc_TEXT_PDU_15(i) == o)and(dec_TEXT_PDU_15(o) == expected_res)) {setverdict(pass);}
305 else {setverdict(fail,"enc_TEXT_PDU_15(i)= ", enc_TEXT_PDU_15(i), "; dec_TEXT_PDU_15(o)= ", dec_TEXT_PDU_15(o));}
306}
307
308
309
310type integer TEXT_PDU_16 with { encode "TEXT"; variant "TEXT_CODING(,,
311 '[1-4]#(1,)')"};
312external function enc_TEXT_PDU_16(in TEXT_PDU_16 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
313external function dec_TEXT_PDU_16(in charstring oct) return TEXT_PDU_16 with { extension "prototype(convert) decode(TEXT)" }
314
315testcase TC_Selection_of_integer_value() runs on TempComp {
316 const TEXT_PDU_16 i := 123423
317 const charstring o := "123423567aBCdfrd"
318 const TEXT_PDU_16 expected_res:= 123423
319
320 if (dec_TEXT_PDU_16(o) == expected_res) {setverdict(pass);}
321 else {setverdict(fail,"enc_TEXT_PDU_16(i)= ", enc_TEXT_PDU_16(i), "; dec_TEXT_PDU_16(o)= ", dec_TEXT_PDU_16(o));}
322}
323
324
325
326type boolean TEXT_PDU_17 with { encode "TEXT"; variant "TEXT_CODING()"};
327external function enc_TEXT_PDU_17(in TEXT_PDU_17 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
328external function dec_TEXT_PDU_17(in charstring oct) return TEXT_PDU_17 with { extension "prototype(convert) decode(TEXT)" }
329
330testcase TC_basic_encoding_of_true_value() runs on TempComp {
331 const TEXT_PDU_17 i := true
332 const charstring o := "true"
333 const TEXT_PDU_17 expected_res:= true
334
335 if ((enc_TEXT_PDU_17(i) == o)and(dec_TEXT_PDU_17(o) == expected_res)) {setverdict(pass);}
336 else {setverdict(fail,"enc_TEXT_PDU_17(i)= ", enc_TEXT_PDU_17(i), "; dec_TEXT_PDU_17(o)= ", dec_TEXT_PDU_17(o));}
337}
338
339
340
341testcase TC_basic_encoding_of_false_value() runs on TempComp {
342 const TEXT_PDU_17 i := false
343 const charstring o := "false"
344 const TEXT_PDU_17 expected_res:= false
345
346 if ((enc_TEXT_PDU_17(i) == o)and(dec_TEXT_PDU_17(o) == expected_res)) {setverdict(pass);}
347 else {setverdict(fail,"enc_TEXT_PDU_17(i)= ", enc_TEXT_PDU_17(i), "; dec_TEXT_PDU_17(o)= ", dec_TEXT_PDU_17(o));}
348}
349
350
351
352type boolean TEXT_PDU_18 with { encode "TEXT"; variant "TEXT_CODING(true:'YES';false:'NO')"};
353external function enc_TEXT_PDU_18(in TEXT_PDU_18 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
354external function dec_TEXT_PDU_18(in charstring oct) return TEXT_PDU_18 with { extension "prototype(convert) decode(TEXT)" }
355
356testcase TC_Encoding_and_decoding_of_given_tokens_1() runs on TempComp {
357 const TEXT_PDU_18 i := false
358 const charstring o := "NO"
359 const TEXT_PDU_18 expected_res:= false
360
361 if ((enc_TEXT_PDU_18(i) == o)and(dec_TEXT_PDU_18(o) == expected_res)) {setverdict(pass);}
362 else {setverdict(fail,"enc_TEXT_PDU_18(i)= ", enc_TEXT_PDU_18(i), "; dec_TEXT_PDU_18(o)= ", dec_TEXT_PDU_18(o));}
363}
364
365
366
367type boolean TEXT_PDU_19 with { encode "TEXT"; variant "TEXT_CODING(true:'YES';false:'NO',
368 true:'good';false:{'bad',case_insensitive})"};
369external function enc_TEXT_PDU_19(in TEXT_PDU_19 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
370external function dec_TEXT_PDU_19(in charstring oct) return TEXT_PDU_19 with { extension "prototype(convert) decode(TEXT)" }
371
372testcase TC_Encoding_and_decoding_of_given_tokens_2() runs on TempComp {
373 const TEXT_PDU_19 i := false
374 const charstring o := "NO"
375 const charstring o2 := "Bad"
376 const TEXT_PDU_19 expected_res:= false
377
378 if ((enc_TEXT_PDU_19(i) == o)and(dec_TEXT_PDU_19(o2) == expected_res)) {setverdict(pass);}
379 else {setverdict(fail,"enc_TEXT_PDU_19(i)= ", enc_TEXT_PDU_19(i), "; dec_TEXT_PDU_19(o)= ", dec_TEXT_PDU_19(o));}
380}
381
382
383
384type enumerated TEXT_PDU_20 {egy,ketto,harom}
385 with { encode "TEXT"; variant "TEXT_CODING()"};
386external function enc_TEXT_PDU_20(in TEXT_PDU_20 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
387external function dec_TEXT_PDU_20(in charstring oct) return TEXT_PDU_20 with { extension "prototype(convert) decode(TEXT)" }
388
389testcase TC_Basic_encoding_of_enumerated_values() runs on TempComp {
390 const TEXT_PDU_20 i := egy
391 const charstring o := "egy"
392 const TEXT_PDU_20 expected_res:= egy
393
394 if ((enc_TEXT_PDU_20(i) == o)and(dec_TEXT_PDU_20(o) == expected_res)) {setverdict(pass);}
395 else {setverdict(fail,"enc_TEXT_PDU_20(i)= ", enc_TEXT_PDU_20(i), "; dec_TEXT_PDU_20(o)= ", dec_TEXT_PDU_20(o));}
396}
397
398
399
400type enumerated TEXT_PDU_21 {egy,ketto,harom}
401 with { encode "TEXT"; variant "TEXT_CODING(egy:'haho';harom:'har',
402 egy:'(haho)|(H)';ketto:{,case_insensitive};
403 harom:{'hArom',case_insensitive})"};
404external function enc_TEXT_PDU_21(in TEXT_PDU_21 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
405external function dec_TEXT_PDU_21(in charstring oct) return TEXT_PDU_21 with { extension "prototype(convert) decode(TEXT)" }
406
407testcase TC_Encoding_of_given_enumerated_values_1() runs on TempComp {
408 const TEXT_PDU_21 i := egy
409 const charstring o := "haho"
410 const TEXT_PDU_21 expected_res:= egy
411
412 if ((enc_TEXT_PDU_21(i) == o)and(dec_TEXT_PDU_21(o) == expected_res)) {setverdict(pass);}
413 else {setverdict(fail,"enc_TEXT_PDU_21(i)= ", enc_TEXT_PDU_21(i), "; dec_TEXT_PDU_21(o)= ", dec_TEXT_PDU_21(o));}
414}
415
416
417testcase TC_Encoding_of_given_enumerated_values_2() runs on TempComp {
418 const TEXT_PDU_21 i := ketto
419 const charstring o1 := "ketto"
420 const charstring o2 := "Ketto"
421 const TEXT_PDU_21 expected_res:= ketto
422
423 if ((enc_TEXT_PDU_21(i) == o1)and(dec_TEXT_PDU_21(o2) == expected_res)) {setverdict(pass);}
424 else {setverdict(fail,"enc_TEXT_PDU_21(i)= ", enc_TEXT_PDU_21(i), "; dec_TEXT_PDU_21(o2)= ", dec_TEXT_PDU_21(o2));}
425}
426
427
428testcase TC_Encoding_of_given_enumerated_values_3() runs on TempComp {
429 const TEXT_PDU_21 i := harom
430 const charstring o1 := "har"
431 const charstring o2 := "haRoM"
432 const TEXT_PDU_21 expected_res:= harom
433
434 if ((enc_TEXT_PDU_21(i) == o1)and(dec_TEXT_PDU_21(o2) == expected_res)) {setverdict(pass);}
435 else {setverdict(fail,"enc_TEXT_PDU_21(i)= ", enc_TEXT_PDU_21(i), "; dec_TEXT_PDU_21(o2)= ", dec_TEXT_PDU_21(o2));}
436}
437
438
439
440type charstring TEXT_PDU_22 with { encode "TEXT"; variant "BEGIN('Header:')"};
441external function enc_TEXT_PDU_22(in TEXT_PDU_22 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
442external function dec_TEXT_PDU_22(in charstring oct) return TEXT_PDU_22 with { extension "prototype(convert) decode(TEXT)" }
443
444testcase TC_Coding_with_leading_token() runs on TempComp {
445 const TEXT_PDU_22 i := "value"
446 const charstring o := "Header:value"
447 const TEXT_PDU_22 expected_res:= "value"
448
449 if ((enc_TEXT_PDU_22(i) == o)and(dec_TEXT_PDU_22(o) == expected_res)) {setverdict(pass);}
450 else {setverdict(fail,"enc_TEXT_PDU_22(i)= ", enc_TEXT_PDU_22(i), "; dec_TEXT_PDU_22(o)= ", dec_TEXT_PDU_22(o));}
451}
452
453
454
455type charstring TEXT_PDU_23 with { encode "TEXT"; variant "BEGIN('Header:',, case_insensitive)"};
456external function enc_TEXT_PDU_23(in TEXT_PDU_23 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
457external function dec_TEXT_PDU_23(in charstring oct) return TEXT_PDU_23 with { extension "prototype(convert) decode(TEXT)" }
458
459testcase TC_Coding_with_leading_token_case_insensitive_decoding() runs on TempComp {
460 const TEXT_PDU_23 i := "value"
461 const charstring o1 := "Header:value"
462 const charstring o2 := "heADer:value"
463 const TEXT_PDU_23 expected_res:= "value"
464
465 if ((enc_TEXT_PDU_23(i) == o1)and(dec_TEXT_PDU_23(o2) == expected_res)) {setverdict(pass);}
466 else {setverdict(fail,"enc_TEXT_PDU_23(i)= ", enc_TEXT_PDU_23(i), "; dec_TEXT_PDU_23(o2)= ", dec_TEXT_PDU_23(o2));}
467}
468
469
470
471type charstring TEXT_PDU_24 with { encode "TEXT"; variant "BEGIN('Header:','(T:)|(Header:)')"};
472external function enc_TEXT_PDU_24(in TEXT_PDU_24 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
473external function dec_TEXT_PDU_24(in charstring oct) return TEXT_PDU_24 with { extension "prototype(convert) decode(TEXT)" }
474
475testcase TC_Coding_with_leading_token_case_insensitive_decoding_1() runs on TempComp {
476 const TEXT_PDU_24 i := "value"
477 const charstring o := "Header:value"
478 const TEXT_PDU_24 expected_res:= "value"
479
480 if ((enc_TEXT_PDU_24(i) == o)and(dec_TEXT_PDU_24(o) == expected_res)) {setverdict(pass);}
481 else {setverdict(fail,"enc_TEXT_PDU_24(i)= ", enc_TEXT_PDU_24(i), "; dec_TEXT_PDU_24(o)= ", dec_TEXT_PDU_24(o));}
482}
483
484
485testcase TC_Coding_with_leading_token_case_insensitive_decoding_2() runs on TempComp {
486 const charstring o := "T:value"
487 const TEXT_PDU_24 expected_res:= "value"
488
489 if (dec_TEXT_PDU_24(o) == expected_res) {setverdict(pass);}
490 else {setverdict(fail,"; dec_TEXT_PDU_24(o)= ", dec_TEXT_PDU_24(o));}
491}
492
493
494
495type charstring TEXT_PDU_25 with { encode "TEXT"; variant "END(':close')"};
496external function enc_TEXT_PDU_25(in TEXT_PDU_25 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
497external function dec_TEXT_PDU_25(in charstring oct) return TEXT_PDU_25 with { extension "prototype(convert) decode(TEXT)" }
498
499testcase TC_Coding_with_trailing_token() runs on TempComp {
500 const TEXT_PDU_25 i := "value"
501 const charstring o := "value:close"
502 const TEXT_PDU_25 expected_res:= "value"
503
504 if ((enc_TEXT_PDU_25(i) == o)and(dec_TEXT_PDU_25(o) == expected_res)) {setverdict(pass);}
505 else {setverdict(fail,"enc_TEXT_PDU_25(i)= ", enc_TEXT_PDU_25(i), "; dec_TEXT_PDU_25(o)= ", dec_TEXT_PDU_25(o));}
506}
507
508
509
510type charstring TEXT_PDU_26 with { encode "TEXT"; variant "END(':close',, case_insensitive)"};
511external function enc_TEXT_PDU_26(in TEXT_PDU_26 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
512external function dec_TEXT_PDU_26(in charstring oct) return TEXT_PDU_26 with { extension "prototype(convert) decode(TEXT)" }
513
514testcase TC_Coding_with_trailing_token_case_insensitive_decoding() runs on TempComp {
515 const TEXT_PDU_26 i := "value"
516 const charstring o1 := "value:close"
517 const charstring o2 := "value:CloSe"
518 const TEXT_PDU_26 expected_res:= "value"
519
520 if ((enc_TEXT_PDU_26(i) == o1)and(dec_TEXT_PDU_26(o2) == expected_res)) {setverdict(pass);}
521 else {setverdict(fail,"enc_TEXT_PDU_26(i)= ", enc_TEXT_PDU_26(i), "; dec_TEXT_PDU_26(o2)= ", dec_TEXT_PDU_26(o2));}
522}
523
524
525
526type charstring TEXT_PDU_27 with { encode "TEXT"; variant "END(':close','(:T)|(:close)')"};
527external function enc_TEXT_PDU_27(in TEXT_PDU_27 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
528external function dec_TEXT_PDU_27(in charstring oct) return TEXT_PDU_27 with { extension "prototype(convert) decode(TEXT)" }
529
530testcase TC_Coding_with_trailing_token_using_decoding_matching_pattern() runs on TempComp {
531 const TEXT_PDU_27 i := "value"
532 const charstring o1 := "value:close"
533 const charstring o2 := "value:T"
534 const TEXT_PDU_27 expected_res:= "value"
535
536 if ((enc_TEXT_PDU_27(i) == o1)and(dec_TEXT_PDU_27(o2) == expected_res)) {setverdict(pass);}
537 else {setverdict(fail,"enc_TEXT_PDU_27(i)= ", enc_TEXT_PDU_27(i), "; dec_TEXT_PDU_27(o2)= ", dec_TEXT_PDU_27(o2));}
538}
539
540
541
542type record TEXT_PDU_28 {
543 charstring f1,
544 charstring f2
545} with { encode "TEXT"; variant "SEPARATOR('\n\r')"};
546external function enc_TEXT_PDU_28(in TEXT_PDU_28 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
547external function dec_TEXT_PDU_28(in charstring oct) return TEXT_PDU_28 with { extension "prototype(convert) decode(TEXT)" }
548
549testcase TC_Coding_with_separator_token() runs on TempComp {
550 const TEXT_PDU_28 i := {f1:="value1",f2:="value2"}
551 const charstring o := "value1\n\rvalue2"
552 const TEXT_PDU_28 expected_res:= {f1:="value1",f2:="value2"}
553
554 if ((enc_TEXT_PDU_28(i) == o)and(dec_TEXT_PDU_28(o) == expected_res)) {setverdict(pass);}
555 else {setverdict(fail,"enc_TEXT_PDU_28(i)= ", enc_TEXT_PDU_28(i), "; dec_TEXT_PDU_28(o)= ", dec_TEXT_PDU_28(o));}
556}
557
558
559
560type record TEXT_PDU_29 {
561 charstring f1,
562 charstring f2
563} with { encode "TEXT"; variant "SEPARATOR(':FieldSep\n\r',,case_insensitive)"};
564external function enc_TEXT_PDU_29(in TEXT_PDU_29 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
565external function dec_TEXT_PDU_29(in charstring oct) return TEXT_PDU_29 with { extension "prototype(convert) decode(TEXT)" }
566
567testcase TC_Coding_with_separator_token_case_insensitive_decoding() runs on TempComp {
568 const charstring o := "value1:FiELDsep\n\rvalue2"
569 const TEXT_PDU_29 expected_res:= {f1:="value1",f2:="value2"}
570
571 if (dec_TEXT_PDU_29(o) == expected_res) {setverdict(pass);}
572 else {setverdict(fail, "; dec_TEXT_PDU_29(o)= ", dec_TEXT_PDU_29(o));}
573}
574
575
576
577type record TEXT_PDU_30 {
578 charstring f1,
579 charstring f2
580} with { encode "TEXT"; variant "SEPARATOR(':FieldSep\n\r','(\n\r)|(:FieldSep\n\r)')"};
581external function enc_TEXT_PDU_30(in TEXT_PDU_30 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
582external function dec_TEXT_PDU_30(in charstring oct) return TEXT_PDU_30 with { extension "prototype(convert) decode(TEXT)" }
583
584testcase TC_Coding_with_separator_token_1() runs on TempComp {
585 const TEXT_PDU_30 i := {f1:="value1",f2:="value2"}
586 const charstring o := "value1:FieldSep\n\rvalue2"
587 const TEXT_PDU_30 expected_res:= {f1:="value1",f2:="value2"}
588
589 if ((enc_TEXT_PDU_30(i) == o)and(dec_TEXT_PDU_30(o) == expected_res)) {setverdict(pass);}
590 else {setverdict(fail,"enc_TEXT_PDU_30(i)= ", enc_TEXT_PDU_30(i), "; dec_TEXT_PDU_30(o)= ", dec_TEXT_PDU_30(o));}
591}
592
593
594testcase TC_Coding_with_separator_token_2() runs on TempComp {
595 const charstring o := "value1\n\rvalue2"
596 const TEXT_PDU_30 expected_res:= {f1:="value1",f2:="value2"}
597
598 if (dec_TEXT_PDU_30(o) == expected_res) {setverdict(pass);}
599 else {setverdict(fail,"; dec_TEXT_PDU_30(o)= ", dec_TEXT_PDU_30(o));}
600}
601
602
603
604type record TEXT_PDU_31 {
605 charstring f1
606} with { encode "TEXT"; variant "BEGIN('Head:'),END(':end')"};
607external function enc_TEXT_PDU_31(in TEXT_PDU_31 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
608external function dec_TEXT_PDU_31(in charstring oct) return TEXT_PDU_31 with { extension "prototype(convert) decode(TEXT)" }
609
610testcase TC_Record_with_BEGIN_END_token() runs on TempComp {
611 const TEXT_PDU_31 i := {f1:="value1"}
612 const charstring o := "Head:value1:end"
613 const TEXT_PDU_31 expected_res:= {f1:="value1"}
614
615 if ((enc_TEXT_PDU_31(i) == o)and(dec_TEXT_PDU_31(o) == expected_res)) {setverdict(pass);}
616 else {setverdict(fail,"enc_TEXT_PDU_31(i)= ", enc_TEXT_PDU_31(i), "; dec_TEXT_PDU_31(o)= ", dec_TEXT_PDU_31(o));}
617}
618
619
620
621type record rec_32{
622 charstring field1,
623 charstring field2
624} with { encode "TEXT";variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
625
626type record TEXT_PDU_32 {
627 rec_32 f1,
628 charstring f2
629} with { encode "TEXT";variant "BEGIN('PDU:'),END(':UDP')"};
630external function enc_TEXT_PDU_32(in TEXT_PDU_32 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
631external function dec_TEXT_PDU_32(in charstring oct) return TEXT_PDU_32 with { extension "prototype(convert) decode(TEXT)" }
632
633testcase TC_Record_with_record_fields() runs on TempComp {
634 const TEXT_PDU_32 i := {f1:={field1:="v1",field2:="v2"},f2:="value1"}
635 const charstring o := "PDU:Head:v1,v2:endvalue1:UDP"
636 const TEXT_PDU_32 expected_res:= {f1:={field1:="v1",field2:="v2"},f2:="value1"}
637
638 if ((enc_TEXT_PDU_32(i) == o)and(dec_TEXT_PDU_32(o) == expected_res)) {setverdict(pass);}
639 else {setverdict(fail,"enc_TEXT_PDU_32(i)= ", enc_TEXT_PDU_32(i), "; dec_TEXT_PDU_32(o)= ", dec_TEXT_PDU_32(o));}
640}
641
642
643
644type record rec_33{
645 charstring field1,
646 charstring field2
647} with { encode "TEXT";variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
648
649type record TEXT_PDU_33 {
650 rec_33 f1 optional,
651 charstring f2
652} with { encode "TEXT"; variant "BEGIN('PDU:'),END(':UDP')"};
653external function enc_TEXT_PDU_33(in TEXT_PDU_33 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
654external function dec_TEXT_PDU_33(in charstring oct) return TEXT_PDU_33 with { extension "prototype(convert) decode(TEXT)" }
655
656testcase TC_Record_with_optional_fields_1() runs on TempComp {
657 const TEXT_PDU_33 i := {f1:={field1:="v1",field2:="v2"},f2:="value1"}
658 const charstring o := "PDU:Head:v1,v2:endvalue1:UDP"
659 const TEXT_PDU_33 expected_res:= {f1:={field1:="v1",field2:="v2"},f2:="value1"}
660
661 if ((enc_TEXT_PDU_33(i) == o)and(dec_TEXT_PDU_33(o) == expected_res)) {setverdict(pass);}
662 else {setverdict(fail,"enc_TEXT_PDU_33(i)= ", enc_TEXT_PDU_33(i), "; dec_TEXT_PDU_33(o)= ", dec_TEXT_PDU_33(o));}
663}
664
665
666testcase TC_Record_with_optional_fields_2() runs on TempComp {
667 const TEXT_PDU_33 i := {f1:=omit,f2:="value1"}
668 const charstring o := "PDU:value1:UDP"
669 const TEXT_PDU_33 expected_res:= {f1:=omit,f2:="value1"}
670
671 if ((enc_TEXT_PDU_33(i) == o)and(dec_TEXT_PDU_33(o) == expected_res)) {setverdict(pass);}
672 else {setverdict(fail,"enc_TEXT_PDU_33(i)= ", enc_TEXT_PDU_33(i), "; dec_TEXT_PDU_33(o)= ", dec_TEXT_PDU_33(o));}
673}
674
675
676
677type set TEXT_PDU_34 {
678 charstring f1
679} with { encode "TEXT"; variant "BEGIN('Head:'),END(':end')"};
680external function enc_TEXT_PDU_34(in TEXT_PDU_34 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
681external function dec_TEXT_PDU_34(in charstring oct) return TEXT_PDU_34 with { extension "prototype(convert) decode(TEXT)" }
682
683testcase TC_Set_with_BEGIN_END_token() runs on TempComp {
684 const TEXT_PDU_34 i := {f1:="value1"}
685 const charstring o := "Head:value1:end"
686 const TEXT_PDU_34 expected_res:= {f1:="value1"}
687
688 if ((enc_TEXT_PDU_34(i) == o)and(dec_TEXT_PDU_34(o) == expected_res)) {setverdict(pass);}
689 else {setverdict(fail,"enc_TEXT_PDU_34(i)= ", enc_TEXT_PDU_34(i), "; dec_TEXT_PDU_34(o)= ", dec_TEXT_PDU_34(o));}
690}
691
692
693
694type set rec_35{
695 charstring field1,
696 charstring field2
697} with { encode "TEXT"; variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
698
699type set TEXT_PDU_35 {
700 rec_35 f1,
701 charstring f2
702} with { encode "TEXT"; variant "BEGIN('PDU:'),END(':UDP'),SEPARATOR(',')"};
703external function enc_TEXT_PDU_35(in TEXT_PDU_35 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
704external function dec_TEXT_PDU_35(in charstring oct) return TEXT_PDU_35 with { extension "prototype(convert) decode(TEXT)" }
705
706testcase TC_Set_with_BEGIN_END_token_1() runs on TempComp {
707 const TEXT_PDU_35 i := {f1:={field1:="v1",field2:="v2"},f2:="value1"}
708 const charstring o := "PDU:Head:v1,v2:end,value1:UDP"
709 const TEXT_PDU_35 expected_res:= {f1:={field1:="v1",field2:="v2"},f2:="value1"}
710
711 if ((enc_TEXT_PDU_35(i) == o)and(dec_TEXT_PDU_35(o) == expected_res)) {setverdict(pass);}
712 else {setverdict(fail,"enc_TEXT_PDU_35(i)= ", enc_TEXT_PDU_35(i), "; dec_TEXT_PDU_35(o)= ", dec_TEXT_PDU_35(o));}
713}
714
715
716testcase TC_Set_with_BEGIN_END_token_2() runs on TempComp {
717 const charstring o := "PDU:value1,Head:v1,v2:end:UDP"
718 const TEXT_PDU_35 expected_res:= {f1:={field1:="v1",field2:="v2"},f2:="value1"}
719
720 if (dec_TEXT_PDU_35(o) == expected_res) {setverdict(pass);}
721 else {setverdict(fail,"; dec_TEXT_PDU_35(o)= ", dec_TEXT_PDU_35(o));}
722}
723
724
725
726type record rec_36{
727 charstring field1,
728 charstring field2
729} with { encode "TEXT"; variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
730
731type set TEXT_PDU_36 {
732 rec_36 f1 optional,
733 charstring f2
734} with { encode "TEXT"; variant "BEGIN('PDU:'),END(':UDP')"};
735external function enc_TEXT_PDU_36(in TEXT_PDU_36 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
736external function dec_TEXT_PDU_36(in charstring oct) return TEXT_PDU_36 with { extension "prototype(convert) decode(TEXT)" }
737
738testcase TC_Set_with_optional_fields_1() runs on TempComp {
739 const TEXT_PDU_36 i := {f1:={field1:="v1",field2:="v2"},f2:="value1"}
740 const charstring o := "PDU:Head:v1,v2:endvalue1:UDP"
741 const TEXT_PDU_36 expected_res:= {f1:={field1:="v1",field2:="v2"},f2:="value1"}
742
743 if ((enc_TEXT_PDU_36(i) == o)and(dec_TEXT_PDU_36(o) == expected_res)) {setverdict(pass);}
744 else {setverdict(fail,"enc_TEXT_PDU_36(i)= ", enc_TEXT_PDU_36(i), "; dec_TEXT_PDU_36(o)= ", dec_TEXT_PDU_36(o));}
745}
746
747
748testcase TC_Set_with_optional_fields_2() runs on TempComp {
749 const TEXT_PDU_36 i := {f1:=omit,f2:="value1"}
750 const charstring o := "PDU:value1:UDP"
751 const TEXT_PDU_36 expected_res:= {f1:=omit,f2:="value1"}
752
753 if ((enc_TEXT_PDU_36(i) == o)and(dec_TEXT_PDU_36(o) == expected_res)) {setverdict(pass);}
754 else {setverdict(fail,"enc_TEXT_PDU_36(i)= ", enc_TEXT_PDU_36(i), "; dec_TEXT_PDU_36(o)= ", dec_TEXT_PDU_36(o));}
755}
756
757
758
759type set of charstring sof_37 with {encode "TEXT"; variant "SEPARATOR(',')"}
760
761type set TEXT_PDU_37 {
762 charstring f1,
763 charstring f2 optional,
764 sof_37 f3,
765 sof_37 f4 optional,
766 sof_37 f5,
767 charstring f6
768} with { encode "TEXT"; variant "BEGIN('Head:'),END(':end')";
769 variant (f1) "BEGIN('f1:')";
770 variant (f2) "BEGIN('f2:')";
771 variant (f3) "BEGIN('f3:')";
772 variant (f4) "BEGIN('f4:'),TEXT_CODING(,repeatable=true)";
773 variant (f5) "BEGIN('f5:'),TEXT_CODING(,repeatable=true)";
774 variant (f6) "BEGIN('f6:')";
775 variant "SEPARATOR(';')" };
776external function enc_TEXT_PDU_37(in TEXT_PDU_37 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
777external function dec_TEXT_PDU_37(in charstring oct) return TEXT_PDU_37 with { extension "prototype(convert) decode(TEXT)" }
778
779testcase TC_Set_with_set_of_type_fields_1() runs on TempComp {
780 const TEXT_PDU_37 i := {f1:="value1",
781 f2:=omit,
782 f3:={"sof1","sof1a","sof1b"},
783 f4:={"sof2","sof2a","sof2b"},
784 f5:={"sof3","sof3a","sof3b"},
785 f6:="value6" }
786 const charstring o := "Head:f1:value1;f3:sof1,sof1a,sof1b;f4:sof2,sof2a,sof2b;f5:sof3,sof3a,sof3b;f6:value6:end"
787 const TEXT_PDU_37 expected_res:= {f1:="value1",
788 f2:=omit,
789 f3:={"sof1","sof1a","sof1b"},
790 f4:={"sof2","sof2a","sof2b"},
791 f5:={"sof3","sof3a","sof3b"},
792 f6:="value6" }
793
794 if ((enc_TEXT_PDU_37(i) == o)and(dec_TEXT_PDU_37(o) == expected_res)) {setverdict(pass);}
795 else {setverdict(fail,"enc_TEXT_PDU_37(i)= ", enc_TEXT_PDU_37(i), "; dec_TEXT_PDU_37(o)= ", dec_TEXT_PDU_37(o));}
796}
797
798
799testcase TC_Set_with_set_of_type_fields_2() runs on TempComp {
800 const charstring o := "Head:f5:sof3a,sof3b;f3:sof1,sof1a,sof1b;f4:sof2;f1:value1;f4:sof2a,sof2b;f5:sof3;f6:value6:end"
801 const TEXT_PDU_37 expected_res:= {f1:="value1",
802 f2:=omit,
803 f3:={"sof1","sof1a","sof1b"},
804 f4:={"sof2","sof2a","sof2b"},
805 f5:={"sof3","sof3a","sof3b"},
806 f6:="value6" }
807
808 if (dec_TEXT_PDU_37(o) == expected_res) {setverdict(pass);}
809 else {setverdict(fail, "; dec_TEXT_PDU_37(o)= ", dec_TEXT_PDU_37(o));}
810}
811
812
813testcase TC_Set_with_set_of_type_fields_3() runs on TempComp {
814 const charstring o := "Head:f5:sof3a,sof3b;f3:sof1,sof1a,sof1b;f1:value1;f5:sof3;f6:value6:end"
815 const TEXT_PDU_37 expected_res:= {f1:="value1",
816 f2:=omit,
817 f3:={"sof1","sof1a","sof1b"},
818 f4:=omit,
819 f5:={"sof3","sof3a","sof3b"},
820 f6:="value6" }
821
822 if (dec_TEXT_PDU_37(o) == expected_res) {setverdict(pass);}
823 else {setverdict(fail, "; dec_TEXT_PDU_37(o)= ", dec_TEXT_PDU_37(o));}
824}
825
826
827
828type record of charstring TEXT_PDU_38
829 with { encode "TEXT"; variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
830external function enc_TEXT_PDU_38(in TEXT_PDU_38 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
831external function dec_TEXT_PDU_38(in charstring oct) return TEXT_PDU_38 with { extension "prototype(convert) decode(TEXT)" }
832
833testcase TC_Record_of_with_BEGIN_END_token() runs on TempComp {
834 const TEXT_PDU_38 i := {"value1","value2","value3"}
835 const charstring o := "Head:value1,value2,value3:end"
836 const TEXT_PDU_38 expected_res:= {"value1","value2","value3"}
837
838 if ((enc_TEXT_PDU_38(i) == o)and(dec_TEXT_PDU_38(o) == expected_res)) {setverdict(pass);}
839 else {setverdict(fail,"enc_TEXT_PDU_38(i)= ", enc_TEXT_PDU_38(i), "; dec_TEXT_PDU_38(o)= ", dec_TEXT_PDU_38(o));}
840}
841
842
843
844type record rec_39{
845 charstring field1,
846 charstring field2
847} with { encode "TEXT"; variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
848
849type record of rec_39 TEXT_PDU_39 with { encode "TEXT"; variant "BEGIN('PDU:'),END(':UDP')"};
850external function enc_TEXT_PDU_39(in TEXT_PDU_39 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
851external function dec_TEXT_PDU_39(in charstring oct) return TEXT_PDU_39 with { extension "prototype(convert) decode(TEXT)" }
852
853testcase TC_Record_of_with_record_fields() runs on TempComp {
854 const TEXT_PDU_39 i := {{field1:="v1",field2:="v2"},{field1:="v3",field2:="v4"}}
855 const charstring o := "PDU:Head:v1,v2:endHead:v3,v4:end:UDP"
856 const TEXT_PDU_39 expected_res:= {{field1:="v1",field2:="v2"},{field1:="v3",field2:="v4"}}
857
858 if ((enc_TEXT_PDU_39(i) == o)and(dec_TEXT_PDU_39(o) == expected_res)) {setverdict(pass);}
859 else {setverdict(fail,"enc_TEXT_PDU_39(i)= ", enc_TEXT_PDU_39(i), "; dec_TEXT_PDU_39(o)= ", dec_TEXT_PDU_39(o));}
860}
861
862
863testcase TC_Empty_Record_of() runs on TempComp {
864 const TEXT_PDU_39 i := {}
865 const charstring o := "PDU::UDP"
866 const TEXT_PDU_39 expected_res:= {}
867
868 if ((enc_TEXT_PDU_39(i) == o)and(dec_TEXT_PDU_39(o) == expected_res)) {setverdict(pass);}
869 else {setverdict(fail,"enc_TEXT_PDU_39(i)= ", enc_TEXT_PDU_39(i), "; dec_TEXT_PDU_39(o)= ", dec_TEXT_PDU_39(o));}
870}
871
872
873
874type union TEXT_PDU_40 {
875 charstring f1,
876 charstring f2
877} with { encode "TEXT"; variant "BEGIN('Head:'),END(':end')";
878 variant (f1) "BEGIN('f1:'),END(':1f')"
879 variant (f2) "BEGIN('f2:'),END(':2f')" };
880external function enc_TEXT_PDU_40(in TEXT_PDU_40 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
881external function dec_TEXT_PDU_40(in charstring oct) return TEXT_PDU_40 with { extension "prototype(convert) decode(TEXT)" }
882
883testcase TC_Union_with_BEGIN_END_token_1() runs on TempComp {
884 const TEXT_PDU_40 i := {f1:="value1"}
885 const charstring o := "Head:f1:value1:1f:end"
886 const TEXT_PDU_40 expected_res:= {f1:="value1"}
887
888 if ((enc_TEXT_PDU_40(i) == o)and(dec_TEXT_PDU_40(o) == expected_res)) {setverdict(pass);}
889 else {setverdict(fail,"enc_TEXT_PDU_40(i)= ", enc_TEXT_PDU_40(i), "; dec_TEXT_PDU_40(o)= ", dec_TEXT_PDU_40(o));}
890}
891
892testcase TC_Union_with_BEGIN_END_token_2() runs on TempComp {
893 const charstring o := "Head:f2:value2:2f:end"
894 const TEXT_PDU_40 expected_res:= {f2:="value2"}
895
896 if (dec_TEXT_PDU_40(o) == expected_res) {setverdict(pass);}
897 else {setverdict(fail,"; dec_TEXT_PDU_40(o)= ", dec_TEXT_PDU_40(o));}
898}
899
900
901
902type union TEXT_PDU_41 {
903 charstring f1,
904 charstring f2
905} with { encode "TEXT"; variant "BEGIN('Head:'),END(':end')";
906 variant (f1) "BEGIN('f1:'),END(':1f')"
907 variant (f2) "BEGIN('f2:'),END(':2f')" };
908external function enc_TEXT_PDU_41(in TEXT_PDU_41 pdu, out charstring cs) with { extension "prototype(fast) encode(TEXT)" }
909external function dec_TEXT_PDU_41(in charstring cs, out TEXT_PDU_41 pdu) with { extension "prototype(fast) decode(TEXT)" }
910
911testcase TC_implicit_message_encoding_prototype_fast_1() runs on TempComp {
912 const TEXT_PDU_41 i := {f1:="value1"}
913 const charstring o := "Head:f1:value1:1f:end"
914 const TEXT_PDU_41 expected_res:= {f1:="value1"}
915
916 var charstring res;
917 enc_TEXT_PDU_41(i, res);
918 var TEXT_PDU_41 dec_pdu;
919 dec_TEXT_PDU_41(o, dec_pdu);
920
921 if ((res == o)and(dec_pdu == expected_res)) {setverdict(pass);}
922 else {setverdict(fail,"enc_TEXT_PDU_41(i)= ", res, "; dec_TEXT_PDU_41(o)= ", dec_pdu);}
923}
924
925testcase TC_implicit_message_encoding_prototype_fast_2() runs on TempComp {
926 const charstring o := "Head:f2:value2:2f:end"
927 const TEXT_PDU_41 expected_res:= {f2:="value2"}
928
929 var TEXT_PDU_41 dec_pdu;
930 dec_TEXT_PDU_41(o, dec_pdu);
931
932 if (dec_pdu == expected_res) {setverdict(pass);}
933 else {setverdict(fail,"; dec_TEXT_PDU_41(o)= ", dec_pdu);}
934}
935
936
937
938type integer TEXT_PDU_42 with { encode "TEXT"; variant "TEXT_CODING()" };
939external function enc_TEXT_PDU_42(in TEXT_PDU_42 pdu, out charstring cs)
940 with { extension "prototype(fast) encode(TEXT)" }
941external function dec_TEXT_PDU_42(in charstring cs, out TEXT_PDU_42 pdu) return integer
942 with { extension "prototype(backtrack) decode(TEXT) errorbehavior(ALL:WARNING)" }
943
944testcase TC_implicit_message_encoding_prototype_backtrack() runs on TempComp {
945 var TEXT_PDU_42 bs := 42;
946 var TEXT_PDU_42 decoded_bs;
947 var charstring enc_bs;
948 var integer ret_val;
949 var charstring invalid_enc_bs := "bruhaha";
950
951 enc_TEXT_PDU_42(bs, enc_bs);
952 ret_val := dec_TEXT_PDU_42(enc_bs, decoded_bs);
953 if (ret_val==0) { setverdict(pass); } else { setverdict(fail); }
954 if (decoded_bs==bs) { setverdict(pass); } else { setverdict(fail); }
955 ret_val := dec_TEXT_PDU_42(invalid_enc_bs, decoded_bs);
956 if (ret_val==1) { setverdict(pass); } else { setverdict(fail); }
957}
958
959
960
961type integer TEXT_PDU_43 with { encode "TEXT"; variant "TEXT_CODING(length=4)" };
962external function dec_TEXT_PDU_43(inout charstring cs, out TEXT_PDU_43 pdu) return integer
963 with { extension "prototype(sliding) decode(TEXT) errorbehavior(ALL:WARNING)" }
964
965testcase TC_implicit_message_encoding_prototype_sliding() runs on TempComp {
966 var TEXT_PDU_43 out_pdu;
967 var charstring enc_pdu1 := " 42 21";
968 var integer ret_val;
969
970 ret_val := dec_TEXT_PDU_43(enc_pdu1, out_pdu);
971 if (ret_val==0 and out_pdu==42) { setverdict(pass); } else { setverdict(fail); }
972 ret_val := dec_TEXT_PDU_43(enc_pdu1, out_pdu);
973 if (ret_val==0 and out_pdu==21) { setverdict(pass); } else { setverdict(fail); }
974 ret_val := dec_TEXT_PDU_43(enc_pdu1, out_pdu);
975}
976
977
978control {
979execute (TC_Fixed_length_encoding());
980execute (TC_Convert_string_to_lower_case_during_encoding());
981execute (TC_Convert_string_to_upper_case_during_encoding());
982execute (TC_Convert_string_to_lower_case_during_encoding_and_upper_during_decoding());
983execute (TC_Convert_string_to_upper_case_during_encoding_and_lower_during_decoding());
984execute (TC_Left_justification());
985execute (TC_Center_justification());
986execute (TC_Right_justification());
987execute (TC_Case_sensitive_selection());
988execute (TC_Case_insensitive_selection());
989execute (TC_Fixed_length_integer());
990execute (TC_Variable_length_integer());
991execute (TC_encoding_without_leading_zero());
992execute (TC_encoding_with_leading_zero());
993execute (TC_encoding_negativ_integer_with_leading_zero());
994execute (TC_Selection_of_integer_value());
995execute (TC_basic_encoding_of_true_value());
996execute (TC_basic_encoding_of_false_value());
997execute (TC_Encoding_and_decoding_of_given_tokens_1());
998execute (TC_Encoding_and_decoding_of_given_tokens_2());
999execute (TC_Basic_encoding_of_enumerated_values());
1000execute (TC_Encoding_of_given_enumerated_values_1());
1001execute (TC_Encoding_of_given_enumerated_values_2());
1002execute (TC_Encoding_of_given_enumerated_values_3());
1003execute (TC_Coding_with_leading_token());
1004execute (TC_Coding_with_leading_token_case_insensitive_decoding());
1005execute (TC_Coding_with_leading_token_case_insensitive_decoding_1());
1006execute (TC_Coding_with_leading_token_case_insensitive_decoding_2());
1007execute (TC_Coding_with_trailing_token());
1008execute (TC_Coding_with_trailing_token_case_insensitive_decoding());
1009execute (TC_Coding_with_trailing_token_using_decoding_matching_pattern());
1010execute (TC_Coding_with_separator_token());
1011execute (TC_Coding_with_separator_token_case_insensitive_decoding());
1012execute (TC_Coding_with_separator_token_1());
1013execute (TC_Coding_with_separator_token_2());
1014execute (TC_Record_with_BEGIN_END_token());
1015execute (TC_Record_with_record_fields());
1016execute (TC_Record_with_optional_fields_1());
1017execute (TC_Record_with_optional_fields_2());
1018execute (TC_Set_with_BEGIN_END_token());
1019execute (TC_Set_with_BEGIN_END_token_1());
1020execute (TC_Set_with_BEGIN_END_token_2());
1021execute (TC_Set_with_optional_fields_1());
1022execute (TC_Set_with_optional_fields_2());
1023execute (TC_Set_with_set_of_type_fields_1());
1024execute (TC_Set_with_set_of_type_fields_2());
1025execute (TC_Set_with_set_of_type_fields_3());
1026execute (TC_Record_of_with_BEGIN_END_token());
1027execute (TC_Record_of_with_record_fields());
1028execute (TC_Empty_Record_of());
1029execute (TC_Union_with_BEGIN_END_token_1());
1030execute (TC_Union_with_BEGIN_END_token_2());
1031execute (TC_implicit_message_encoding_prototype_fast_1());
1032execute (TC_implicit_message_encoding_prototype_fast_2());
1033execute (TC_implicit_message_encoding_prototype_backtrack());
1034execute (TC_implicit_message_encoding_prototype_sliding());
1035}
1036
1037<RESULT>
1038Overall verdict: pass
1039<END_TC>
1040
1041:exmp.
1042
1043.*---------------------------------------------------------------------*
1044:h2. Encoding/decoding of big integers
1045.*---------------------------------------------------------------------*
1046.*---------------------------------------------------------------------*
1047:h3.Big integer fields
1048.*---------------------------------------------------------------------*
1049:xmp tab=0.
1050
1051
1052<TC - big integers: big integer fields>
1053<STATIC>
1054
1055external function enc_text(in rec_text r) return charstring
1056 with { extension "encode(TEXT) prototype(convert) errorbehavior(ALL:WARNING)" }
1057external function dec_text(in charstring r) return rec_text
1058 with { extension "decode(TEXT) prototype(convert) errorbehavior(ALL:WARNING)" }
1059
1060type integer myint1 with {
1061 variant "BEGIN('<myint>')"
1062 variant "END('</myint>')"
1063 encode "TEXT" }
1064
1065type integer myint2 with {
1066 variant "BEGIN('<myint_dummy>')"
1067 variant "END('</myint_dummy>')"
1068 variant "TEXT_CODING(length=128;leading0=true)"
1069 encode "TEXT" }
1070
1071type integer myint3 with {
1072 variant "BEGIN('<myint_super>')"
1073 variant "END('</myint_super>')"
1074 encode "TEXT" }
1075
1076type integer myint4 with {
1077 variant "TEXT_CODING(length=256)"
1078 variant "BEGIN('<myint_pad>')"
1079 variant "END('</myint_pad>')"
1080 encode "TEXT" }
1081
1082type record rec_text {
1083 myint1 int1,
1084 myint1 int2,
1085 myint2 int3 optional,
1086 myint3 int4 optional,
1087 myint4 int5 optional
1088} with {
1089 variant "BEGIN('<rec_text>')"
1090 // `variant "SEPARATOR(',')"' is not necessary if the fields can be found
1091 // unambigously.
1092 variant "END('</rec_text>')"
1093 encode "TEXT" }
1094
1095<TTCN_TC:EXEC>
1096 const integer a := 214748364799
1097 const integer b := 214748364788
1098 const integer c := 0
1099 // Implicit `omit' would be great.
1100 var rec_text myrec1 := {int1 := 214748364799, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}
1101 var rec_text myrec2 := {214748364799, 214748364788, omit, omit, omit}
1102 var rec_text myrec3 := {214748364799, 0, omit, omit, omit}
1103 var rec_text myrec4 := {int1 := 214748364799, int2 := 0, int3 := omit, int4 := omit, int5 := omit}
1104 var rec_text myrec5 := {int1 := 0, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}
1105 var rec_text myrec6 := {0, 214748364788, omit, omit, omit}
1106 var rec_text myrec7 := {0, 0, omit, omit, omit}
1107 var rec_text myrec8 := {int1 := 0, int2 := 0, int3 := omit, int4 := omit, int5 := omit}
1108 var rec_text myrec9 := {int1 := a, int2 := b, int3 := omit, int4 := omit, int5 := omit}
1109 var rec_text myrec10 := {a, b, omit, omit, omit}
1110 // The original `sprintf' encoder encodes negative values `-' <padding>
1111 // `0123456'. We should work similarly.
1112 var rec_text myrec11 := {
1113 int1 := -11111111111111111111111111111,
1114 int2 := 22222222222222222222222222222,
1115 int3 := -33333333333333333333333333333,
1116 int4 := 2147483648,
1117 int5 := -2147483648 }
1118 var rec_text myrec12 := {int1 := 0, int2 := 0, int3 := 0, int4 := -1111111111111111111111111111111, int5 := -1234567891011121314151617181920}
1119 var rec_text myrec13 := {-0, -0, -0, -0, -0}
1120 var rec_text myrec14 := {-0, -1, 1234567891011121314151617181920, -1111111111111111111111111111111, -0}
1121 var rec_text myrec15 := {int1 := 1111111111111111111111111111111, int2 := -1234567891011121314151617181920, int3 := 0, int4 := -0, int5 := -111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111}
1122 var charstring ret_val
1123 ret_val := enc_text(myrec1)
1124 if (dec_text(ret_val) == myrec1) { setverdict(pass) } else { setverdict(fail) }
1125 if (dec_text(ret_val) == {int1 := 214748364799, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1126 ret_val := enc_text(myrec2)
1127 if (dec_text(ret_val) == myrec2) { setverdict(pass) } else { setverdict(fail) }
1128 if (dec_text(ret_val) == {214748364799, 214748364788, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1129 ret_val := enc_text(myrec3)
1130 if (dec_text(ret_val) == myrec3) { setverdict(pass) } else { setverdict(fail) }
1131 if (dec_text(ret_val) == {214748364799, 0, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1132 ret_val := enc_text(myrec4)
1133 if (dec_text(ret_val) == myrec4) { setverdict(pass) } else { setverdict(fail) }
1134 if (dec_text(ret_val) == {int1 := 214748364799, int2 := 0, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1135 ret_val := enc_text(myrec5)
1136 if (dec_text(ret_val) == myrec5) { setverdict(pass) } else { setverdict(fail) }
1137 if (dec_text(ret_val) == {int1 := 0, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1138 ret_val := enc_text(myrec6)
1139 if (dec_text(ret_val) == myrec6) { setverdict(pass) } else { setverdict(fail) }
1140 if (dec_text(ret_val) == {0, 214748364788, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1141 ret_val := enc_text(myrec7)
1142 if (dec_text(ret_val) == myrec7) { setverdict(pass) } else { setverdict(fail) }
1143 if (dec_text(ret_val) == {0, 0, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1144 ret_val := enc_text(myrec8)
1145 if (dec_text(ret_val) == myrec8) { setverdict(pass) } else { setverdict(fail) }
1146 if (dec_text(ret_val) == {int1 := 0, int2 := 0, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1147 ret_val := enc_text(myrec9)
1148 if (dec_text(ret_val) == myrec9) { setverdict(pass) } else { setverdict(fail) }
1149 if (dec_text(ret_val) == {int1 := a, int2 := b, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1150 ret_val := enc_text(myrec10)
1151 if (dec_text(ret_val) == myrec10) { setverdict(pass) } else { setverdict(fail) }
1152 if (dec_text(ret_val) == {a, b, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1153 ret_val := enc_text(myrec11)
1154 if (dec_text(ret_val) == myrec11) { setverdict(pass) } else { setverdict(fail) }
1155 if (dec_text(ret_val) == {int1 := -11111111111111111111111111111, int2 := 22222222222222222222222222222, int3 := -33333333333333333333333333333, int4 := 2147483648, int5 := -2147483648}) { setverdict(pass) } else { setverdict(fail) }
1156 ret_val := enc_text(myrec12)
1157 if (dec_text(ret_val) == myrec12) { setverdict(pass) } else { setverdict(fail) }
1158 if (dec_text(ret_val) == {int1 := 0, int2 := 0, int3 := 0, int4 := -1111111111111111111111111111111, int5 := -1234567891011121314151617181920}) { setverdict(pass) } else { setverdict(fail) }
1159 ret_val := enc_text(myrec13)
1160 if (dec_text(ret_val) == myrec13) { setverdict(pass) } else { setverdict(fail) }
1161 if (dec_text(ret_val) == {-0, -0, -0, -0, -0}) { setverdict(pass) } else { setverdict(fail) }
1162 ret_val := enc_text(myrec14)
1163 if (dec_text(ret_val) == myrec14) { setverdict(pass) } else { setverdict(fail) }
1164 if (dec_text(ret_val) == {-0, -1, 1234567891011121314151617181920, -1111111111111111111111111111111, -0}) { setverdict(pass) } else { setverdict(fail) }
1165 ret_val := enc_text(myrec15)
1166 if (dec_text(ret_val) == myrec15) { setverdict(pass) } else { setverdict(fail) }
1167 if (dec_text(ret_val) == {int1 := 1111111111111111111111111111111, int2 := -1234567891011121314151617181920, int3 := 0, int4 := -0, int5 := -111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111}) { setverdict(pass) } else { setverdict(fail) }
1168
1169<RESULT>
1170Overall verdict: pass
1171<END_TC>
1172
1173:exmp.
1174
1175.*---------------------------------------------------------------------*
1176:h3.Sliding encoding/decoding of big integers
1177.*---------------------------------------------------------------------*
1178:xmp tab=0.
1179
1180
1181<TC - big integers: sliding encoding/decoding of big integers>
1182<STATIC>
1183
1184external function dec_text_sliding(inout charstring r, out myint5 s) return integer
1185 with { extension "prototype(sliding) decode(TEXT) errorbehavior(ALL:WARNING)" }
1186
1187type integer myint5 with { encode "TEXT"; variant "TEXT_CODING(length=25)" }
1188
1189<TTCN_TC:EXEC>
1190 var myint5 decoded
1191 var charstring encoded := " 12345678910111213141516 -11111111111111111111"
1192 var integer ret_val
1193 var template integer intt := 12345678910111213141516
1194 ret_val := dec_text_sliding(encoded, decoded)
1195 if (ret_val == 0 and decoded == 12345678910111213141516) {setverdict(pass)}
1196 else {setverdict(fail)}
1197 ret_val := dec_text_sliding(encoded, decoded)
1198 if (ret_val == 0 and decoded == -11111111111111111111) {setverdict(pass)}
1199 else {setverdict(fail)}
1200 ret_val := dec_text_sliding(encoded, decoded)
1201 if (match(12345678910111213141516, intt)) {setverdict(pass)}
1202 else {setverdict(fail)}
1203
1204<RESULT>
1205Overall verdict: pass
1206<END_TC>
1207
1208:exmp.
1209.*---------------------------------------------------------------------*
1210:h1.REFERENCES
1211.*---------------------------------------------------------------------*
1212:nl. Requirement specification(s):
1213:nl.-------------------------------
1214:list.
1215:li. 3/ETH/RUS-2003:0087 Uen - Requirement Specification for TITAN's TTCN-3 Semantic Analyser
1216:elist.
1217
1218:etext.
Titan Core - Deliverables
This page took 0.067477 seconds and 5 git commands to generate.