Commit | Line | Data |
---|---|---|
970ed795 | 1 | /****************************************************************************** |
d44e3c4f | 2 | * Copyright (c) 2000-2016 Ericsson Telecom AB |
970ed795 EL |
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 | |
d44e3c4f | 7 | * |
8 | * Contributors: | |
9 | * Balasko, Jeno | |
10 | * Kovacs, Ferenc | |
11 | * Raduly, Csaba | |
12 | * Szabados, Kristof | |
13 | * | |
970ed795 EL |
14 | ******************************************************************************/ |
15 | module TassignmentNotation | |
16 | { | |
17 | import from ASN_Definitions language "ASN.1 : 1997" all | |
18 | type component empty { } | |
19 | type record tri | |
20 | { | |
21 | integer a, | |
22 | integer b, | |
23 | integer c | |
24 | } | |
25 | function f1 () return integer { return 100 } | |
26 | type record of tri tritri | |
27 | type record of tritri tritritri | |
28 | modulepar tritri tsp_param := | |
29 | { | |
30 | { 0, 1, 2 }, | |
31 | { 4, 5, 6 } | |
32 | } | |
33 | modulepar tritritri tsp_param_param := | |
34 | { | |
35 | { { 10, 11, 12 }, { 13, 14, 15 } }, | |
36 | { { 16, 17, 18 }, { 19, 20, 21 } } | |
37 | } | |
38 | modulepar integer tsp_index := 0 | |
39 | modulepar charstring tsp_editor := "mcedit" | |
40 | testcase asns () runs on empty | |
41 | { | |
42 | template ASN_SEQ_R asn_temp := { asn_seq_i := { 0, 1, 2 } } | |
43 | template ASN_SEQ_R asn_temp_mod modifies asn_temp := { asn_seq_i := { [1] := 0, [2] := 0 } } | |
44 | var ASN_SEQ_R asn_temp_exp := { asn_seq_i := { 0, 0, 0 } } | |
45 | if (match (asn_temp_exp, asn_temp_mod)) { setverdict (pass) } | |
46 | else { setverdict (fail, __LINE__) } | |
47 | var integer index := 1 | |
48 | var ASN_SEQ_I v1 := { 1, 2, 3 } | |
49 | var ASN_SEQ_I v2 := { [0] := 100, [index] := 200, [index + 1] := 300 } | |
50 | var ASN_SEQ_I v1_exp := { 100, 200, 300 } | |
51 | v1[0] := 100 * v1[0] | |
52 | v1[index] := 100 * v1[index + 1 - 1] | |
53 | v1[index + 1] := v2[2] | |
54 | if (v1 != v2) { setverdict (fail, __LINE__) } | |
55 | else { setverdict (pass) } | |
56 | v1 := { 100 } | |
57 | /* Evaluated from left to right. */ | |
58 | v1 := { [sizeof (v1)] := 200, [sizeof (v1)] := 300 } | |
59 | if (v1 != v1_exp) { setverdict (fail, __LINE__) } | |
60 | else { setverdict (pass) } | |
61 | var ASN_SEQ_R v3 := { asn_seq_i := { 1, 2, 3 } } | |
62 | var ASN_SEQ_R v4 := { asn_seq_i := { [index] := 111 } } | |
63 | var ASN_SEQ_R v3_exp := { asn_seq_i := { 11, 22, 33 } } | |
64 | var ASN_SEQ_R v5 := { asn_seq_i := { [1000 + index + sizeof (v3.asn_seq_i)] := 1000 } } | |
65 | v4.asn_seq_i[index] := 22 | |
66 | v4 := { asn_seq_i := { [index - 1] := index + 10, [2] := 33 } } | |
67 | v3 := v4 | |
68 | v3 := { asn_seq_i := { [index - 1] := 11 } } | |
69 | if (v3 != v3_exp) { setverdict (fail, __LINE__) } | |
70 | else { setverdict (pass) } | |
71 | v4.asn_seq_i[0] := v3.asn_seq_i[0] | |
72 | if (v4 != v3_exp) { setverdict (fail, __LINE__) } | |
73 | else { setverdict (pass) } | |
74 | if (isvalue (v4)) { setverdict (pass) } | |
75 | else { setverdict (fail, __LINE__) } | |
76 | if (isvalue (v4.asn_seq_i[index])) { setverdict (pass) } | |
77 | else { setverdict (fail, __LINE__) } | |
78 | if (isvalue (v2[valueof (asn_temp_mod.asn_seq_i[0])])) { setverdict (pass) } | |
79 | else { setverdict (fail, __LINE__) } | |
80 | if (sizeof (v5.asn_seq_i) == 1005) { setverdict (pass) } | |
81 | else { setverdict (fail, __LINE__) } | |
82 | if (isvalue (asn_temp_mod)) { setverdict (pass) } | |
83 | else { setverdict (fail, __LINE__) } | |
84 | /* Template with uninitialized elements. */ | |
85 | template ASN_SEQ_R mod2 modifies asn_temp_mod := { asn_seq_i := { [100] := 0, [200] := 0 } } | |
86 | if (not isvalue (mod2)) { setverdict (pass) } | |
87 | else { setverdict (fail, __LINE__) } | |
88 | if (not isvalue (mod2.asn_seq_i)) { setverdict (pass) } | |
89 | else { setverdict (fail, __LINE__) } | |
90 | } | |
91 | type record array_element { integer a, integer b } | |
92 | type array_element array_elements[4] | |
93 | type record of array_element array_record_of | |
94 | type record of integer intlist | |
95 | type set of integer intset | |
96 | testcase arrays () runs on empty | |
97 | { | |
98 | var integer first := 0 | |
99 | var integer second := 1 | |
100 | var integer third := 2 | |
101 | var array_element arr2[4] | |
102 | var array_element arr3[14] | |
103 | var array_elements array := | |
104 | { | |
105 | [first] := { first, 0 }, | |
106 | [second] := { 1, second }, | |
107 | [third] := { third, 2 }, | |
108 | [third + 1] := { 3, third + 1 } | |
109 | } | |
110 | arr2 := array | |
111 | arr2 := { [3] := { 100, third } } | |
112 | arr3 := { [10] := arr2[1] } | |
113 | var array_elements array_expected := { { 0, 0 }, { 1, 1 }, { 2, 2 }, { 3, third + 1 } } | |
114 | if (array == array_expected) { setverdict (pass) } | |
115 | else { setverdict (fail, __LINE__) } | |
116 | template array_elements array_base := { { 100, 200 }, { -1, -2 }, { 1000, 2000 }, { -10, -20 } } | |
117 | template array_elements array_modified modifies array_base := | |
118 | { | |
119 | [0] := { 0, 0 }, | |
120 | [2] := { third, third }, | |
121 | [second] := { 1, first + 1 }, | |
122 | [third + 1] := { third + 1, 3 } | |
123 | } | |
124 | if (match (array_expected, array_modified)) { setverdict (pass) } | |
125 | else { setverdict (fail, __LINE__) } | |
126 | /* "array[500 + f1 ()]" is a dynamic test case error. */ | |
127 | if (isvalue (array[500 + f1 () - 599])) { setverdict (pass) } | |
128 | else { setverdict (fail, __LINE__) } | |
129 | if (isvalue (array)) { setverdict (pass) } | |
130 | else { setverdict (fail, __LINE__) } | |
131 | if (isvalue (array[f1 () - f1 () + 1].a)) { setverdict (pass) } | |
132 | else { setverdict (fail, __LINE__) } | |
133 | if (isvalue (arr2[500 + f1 () - 598])) { setverdict (pass) } | |
134 | else { setverdict (fail, __LINE__) } | |
135 | if (isvalue (arr2)) { setverdict (pass) } | |
136 | else { setverdict (fail, __LINE__) } | |
137 | if (not isvalue (arr3)) { setverdict (pass) } | |
138 | else { setverdict (fail, __LINE__) } | |
139 | if (isvalue (arr2[f1 () - f1 () + 1].a)) { setverdict (pass) } | |
140 | else { setverdict (fail, __LINE__) } | |
141 | if (sizeof (arr3) == 14) { setverdict (pass) } | |
142 | else { setverdict (fail, __LINE__) } | |
143 | /* Creating holes in arrays is not possible. (Without dynamic test case | |
144 | error.) */ | |
145 | } | |
146 | testcase configs () runs on empty | |
147 | { | |
148 | template tritri tsp_param_expected := | |
149 | { | |
150 | { 0, 1, 2 }, | |
151 | { 3, 4, 5 }, | |
152 | { 33, 22, 11 }, | |
153 | { 100, 100, 100 } | |
154 | } | |
155 | var tritri tsp_param_exp2 := | |
156 | { | |
157 | [0] := { 0, 1, 2 }, | |
158 | [1] := { 3, 4, 5 }, | |
159 | [2] := { 33, 22, 11 }, | |
160 | [3] := { 100, 100, 100 } | |
161 | } | |
162 | var tritri tsp_param_exp3 := | |
163 | { | |
164 | [0] := { 0, 1, 2 }, | |
165 | [3] := { 3, 4, 5 }, | |
166 | [2] := { 33, 22, 11 }, | |
167 | [1] := { 100, 100, 100 } | |
168 | } | |
169 | if (match (tsp_param, tsp_param_expected)) { setverdict (pass) } | |
170 | else { setverdict (fail, __LINE__) } | |
171 | if (tsp_param == tsp_param_exp2) { setverdict (pass) } | |
172 | else { setverdict (fail, __LINE__) } | |
173 | if (tsp_param != tsp_param_exp3) { setverdict (pass) } | |
174 | else { setverdict (fail, __LINE__) } | |
175 | } | |
176 | type record of my mylist | |
177 | type set of my_set myset | |
178 | type record my { intlist ilist, integer i } | |
179 | type record my_set { intset iset, integer i } | |
180 | type record dummy { mylist mlist } | |
181 | type record dummy_set { myset mset } | |
182 | testcase recofs () runs on empty | |
183 | { | |
184 | template dummy t1 := { mlist := { { ilist := { 0 }, i := 0 } } } | |
185 | template dummy t1_mod1 modifies t1 := { mlist := { [0] := { ilist := { 1 } } } } | |
186 | var dummy t1_mod_exp := { mlist := { { ilist := { 1 }, i := 0 } } } | |
187 | if (match (t1_mod_exp, t1_mod1)) { setverdict (pass) } | |
188 | else { setverdict (fail, __LINE__) } | |
189 | var integer index := 0 | |
190 | /* An index like "index + 1 - 1" caused circular reference with previous | |
191 | versions. The name was not set correctly. */ | |
192 | template dummy t1_mod2 modifies t1 := { mlist := { [index + 1 - index - 1] := { ilist := { [0 - index] := index + 1 } } } } | |
193 | if (match (t1_mod_exp, t1_mod2)) { setverdict (pass) } | |
194 | else { setverdict (fail, __LINE__) } | |
195 | var intlist v1 := { [0] := 0, [index + 1] := 1 } | |
196 | var intlist v1_exp := { 100, 1 } | |
197 | var intlist v3 := { [100 + f1 ()] := 100 } | |
198 | v1[1] := index + 1 | |
199 | v1 := { [0] := 100 } | |
200 | if (v1 == v1_exp) { setverdict (pass) } | |
201 | else { setverdict (fail, __LINE__) } | |
202 | var dummy v2 := { mlist := { { ilist := { 1, 2 }, i := 500 } } } | |
203 | v2 := { mlist := { { ilist := { [index + 2] := 3 }, i := v2.mlist[index].i - 100 } } } | |
204 | var dummy v2_exp := { mlist := { { ilist := { -, -, 3 }, i := 400 } } } | |
205 | if (v2 == v2_exp) { setverdict (pass) } | |
206 | else { setverdict (fail, __LINE__, ": ", match(v2, v2_exp)) } | |
207 | if (not isvalue (t1_mod2.mlist[500])) { setverdict (pass) } | |
208 | else { setverdict (fail, __LINE__) } | |
209 | if (isvalue (t1_mod2.mlist[0])) { setverdict (pass) } | |
210 | else { setverdict (fail, __LINE__) } | |
211 | if (not isvalue (t1_mod2.mlist[1])) { setverdict (pass) } | |
212 | else { setverdict (fail, __LINE__) } | |
213 | if (not isvalue (v2)) { setverdict (pass) } | |
214 | else { setverdict (fail, __LINE__) } | |
215 | if (not isvalue (v2.mlist[index].ilist[1])) { setverdict (pass) } | |
216 | else { setverdict (fail, __LINE__) } | |
217 | if (isvalue (v1)) { setverdict (pass) } | |
218 | else { setverdict (fail, __LINE__) } | |
219 | if (isvalue (v1[0])) { setverdict (pass) } | |
220 | else { setverdict (fail, __LINE__) } | |
221 | if (not isvalue (v3)) { setverdict (pass) } | |
222 | else { setverdict (fail, __LINE__) } | |
223 | if (isvalue (v3[200])) { setverdict (pass) } | |
224 | else { setverdict (fail, __LINE__) } | |
225 | if (sizeof (v3) == 201) { setverdict (pass) } | |
226 | else { setverdict (fail, __LINE__) } | |
227 | } | |
228 | testcase setofs () runs on empty | |
229 | { /* Same as the previous. */ | |
230 | template dummy_set t1 := { mset := { { iset := { 0 }, i := 0 } } } | |
231 | template dummy_set t1_mod1 modifies t1 := { mset := { [0] := { iset := { 1 } } } } | |
232 | var dummy_set t1_mod_exp := { mset := { { iset := { 1 }, i := 0 } } } | |
233 | if (match (t1_mod_exp, t1_mod1)) { setverdict (pass) } | |
234 | else { setverdict (fail, __LINE__) } | |
235 | var integer index := 0 | |
236 | template dummy_set t1_mod2 modifies t1 := { mset := { [index + 1 - index - 1] := { iset := { [0 - index] := index + 1 } } } } | |
237 | if (match (t1_mod_exp, t1_mod2)) { setverdict (pass) } | |
238 | else { setverdict (fail, __LINE__) } | |
239 | var intset v1 := { [0] := 0, [index + 1] := 1 } | |
240 | var intset v1_exp := { 100, 1 } | |
241 | v1[1] := index + 1 | |
242 | v1 := { [0] := 100 } | |
243 | if (v1 == v1_exp) { setverdict (pass) } | |
244 | else { setverdict (fail, __LINE__) } | |
245 | var dummy_set v2 := { mset := { { iset := { 1, 2 }, i := 500 } } } | |
246 | var dummy_set v2_exp := { mset := { { iset := { -, -, 3 }, i := 400 } } } | |
247 | var intset v3 := { [100 + f1 ()] := 100 } | |
248 | v2 := { mset := { { iset := { [index + 2] := 3 }, i := v2.mset[index].i - 100 } } } | |
249 | if (v2 == v2_exp) { setverdict (pass) } | |
250 | else { setverdict (fail, __LINE__, ": ", match(v2, v2_exp)) } | |
251 | /* It should be a compile only test. */ | |
252 | var ASN_CSTR asnstr | |
253 | asnstr := { { fixed := NULL }, "{ itu-t identified-organization etsi(0) reserved(127) etsi-identified-organization(0) ericsson(5) }", 'abcd'O }; | |
254 | var objid oi := objid { itu_t (0) 1 2 } | |
255 | /* Using isvalue. */ | |
256 | if (isvalue (t1_mod2)) { setverdict (pass) } | |
257 | else { setverdict (fail, __LINE__) } | |
258 | if (isvalue (t1_mod2.mset)) { setverdict (pass) } | |
259 | else { setverdict (fail, __LINE__) } | |
260 | /* Indexing with constants was a problem with INDEXED_TEMPLATE_LIST | |
261 | nodes. */ | |
262 | if (not isvalue (t1_mod2.mset[500])) { setverdict (pass) } | |
263 | else { setverdict (fail, __LINE__) } | |
264 | if (isvalue (t1_mod2.mset[0])) { setverdict (pass) } | |
265 | else { setverdict (fail, __LINE__) } | |
266 | if (not isvalue (t1_mod2.mset[1])) { setverdict (pass) } | |
267 | else { setverdict (fail, __LINE__) } | |
268 | if (not isvalue (v2)) { setverdict (pass) } | |
269 | else { setverdict (fail, __LINE__) } | |
270 | if (not isvalue (v2.mset[index].iset[1])) { setverdict (pass) } | |
271 | else { setverdict (fail, __LINE__) } | |
272 | if (isvalue (v1)) { setverdict (pass) } | |
273 | else { setverdict (fail, __LINE__) } | |
274 | if (isvalue (v1[0])) { setverdict (pass) } | |
275 | else { setverdict (fail, __LINE__) } | |
276 | if (not isvalue (v3)) { setverdict (pass) } | |
277 | else { setverdict (fail, __LINE__) } | |
278 | if (isvalue (v3[200])) { setverdict (pass) } | |
279 | else { setverdict (fail, __LINE__) } | |
280 | if (sizeof (v3) == 201) { setverdict (pass) } | |
281 | else { setverdict (fail, __LINE__) } | |
282 | } | |
283 | ||
284 | type integer intarr[2..5] | |
285 | ||
286 | testcase tc_TR938_939() runs on empty { | |
287 | // Constants with the same base-types, but initialized in different ways. | |
288 | // All the same. Evaluated during CP. It's specific to the mentioned | |
289 | // TR939, but the restructuring for TR938 should make this obsolete. | |
290 | const intlist il1 := { [0] := 0, [1] := 1 } | |
291 | const intlist il2 := { [0] := 0, [1] := 1 } | |
292 | const intlist il3 := { [1] := 1, [0] := 0 } | |
293 | const intlist il4 := { 0, 1 } | |
294 | const intlist il5 := { 1, 0 } | |
295 | const intlist il6 := { 0, 1, 2 } | |
296 | const intlist il7 := { [0] := 0, [1] := 1, [2] := 2 } | |
297 | const intlist il8 := { [2] := 2, [1] := 1, [0] := 0 } | |
298 | if (il1 == il1) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
299 | if (il1 == il2) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
300 | if (il1 == il3) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
301 | if (il1 == il4) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
302 | if (il1 == il2 and il2 == il3 | |
303 | and il3 == il4) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
304 | if (il1 != il5) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
305 | if (il1 != il6) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
306 | if (il1 != il7) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
307 | if (il1 != il8) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
308 | // Initializing value-range arrays. | |
309 | var intarr ia1 := { [2] := 2, [3] := 3, [4] := 4, [5] := 5 } | |
310 | var intarr ia2 := { 2, 3, 4, 5 } | |
311 | if (ia1 == ia2) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
312 | // Initializing arrays using dynamic index values. | |
313 | var integer i := 2 | |
314 | var intarr ia3 := { [i] := 2, [i] := 2 } | |
315 | ia3[i + 1] := 3; ia3[i + 2] := 4; ia3[i + 3] := 5 | |
316 | var intarr ia4 := { [i] := 2, [i] := 2 } | |
317 | ia4[i + 1] := 3; ia4[i + 2] := 4; ia4[i + 3] := 5 | |
318 | if (ia3 == ia4) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
319 | } | |
320 | ||
321 | // Test for TR943. The code section was not set correctly for references from | |
322 | // different modules. The module of the referenced index should come after | |
323 | // this module. Otherwise, the test is useless. | |
324 | template intlist t_intlist := { 0 } | |
325 | template intlist tm_intlist modifies t_intlist := { [idx_ASN] := 1 } | |
326 | testcase tc_TR943() runs on empty { | |
327 | // Same for values. | |
328 | var intlist il1 := { [idx_ASN] := 1 } | |
329 | if (il1 == { 1 }) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
330 | if (match(il1, tm_intlist)) { setverdict(pass) } else { setverdict(fail, __LINE__) } | |
331 | } | |
332 | ||
333 | control | |
334 | { | |
335 | execute (asns ()) | |
336 | execute (recofs ()) | |
337 | execute (setofs ()) | |
338 | execute (arrays ()) | |
339 | execute (configs ()) | |
340 | execute (tc_TR938_939 ()) | |
341 | execute (tc_TR943 ()) | |
342 | } | |
343 | } |