1InfObj DEFINITIONS ::=
2BEGIN
3
4
5RANAP-ELEMENTARY-PROCEDURE ::= CLASS {
6    &InitiatingMessage				,
7    &SuccessfulOutcome				OPTIONAL,
8    &Outcome				DEFAULT NULL,
9    &vartypvalue                        &Outcome OPTIONAL,
10    &FixTypeValSet                      PrintableString OPTIONAL,
11    &VarTypeValSet                      &InitiatingMessage OPTIONAL,
12    &infoObject                         RANAP-ELEMENTARY-PROCEDURE OPTIONAL,
13    &InfObjectSet                       CLASS2 OPTIONAL,
14    &UnsuccessfulOutcome				OPTIONAL,
15    &procedureCode			ProcedureCode 	UNIQUE,
16    &criticality			Criticality 	DEFAULT ignore
17}
18WITH SYNTAX {
19  INITIATING MESSAGE		&InitiatingMessage
20  [SUCCESSFUL OUTCOME		&SuccessfulOutcome]
21  [UNSUCCESSFUL OUTCOME		&UnsuccessfulOutcome]
22  [OUTCOME			&Outcome]
23  PROCEDURE CODE				&procedureCode
24  [CRITICALITY			&criticality]
25  [VARTYPEVALUE                 &vartypvalue]
26  [FIXT                         &FixTypeValSet]
27  [VART                         &VarTypeValSet]
28  [INFOOBJECT                   &infoObject]
29  [INFOOBJECTSET                &InfObjectSet]
30}
31
32RANAP-PDU ::= CHOICE {
33	initiatingMessage	InitiatingMessage,
34--	successfulOutcome	SuccessfulOutcome,
35--	unsuccessfulOutcome	UnsuccessfulOutcome,
36--	outcome			Outcome,
37	...
38}
39
40CLASS2 ::= RANAP-ELEMENTARY-PROCEDURE
41
42InitiatingMessage  ::= SEQUENCE {
43    procedureCode  RANAP-ELEMENTARY-PROCEDURE.&procedureCode	({RANAP-ELEMENTARY-PROCEDURES}),
44    criticality	RANAP-ELEMENTARY-PROCEDURE.&criticality		({RANAP-ELEMENTARY-PROCEDURES}{@procedureCode}),
45    value	RANAP-ELEMENTARY-PROCEDURE.&InitiatingMessage	({RANAP-ELEMENTARY-PROCEDURES}{@procedureCode})
46    }
47
48iu-Release RANAP-ELEMENTARY-PROCEDURE ::= {
49    INITIATING MESSAGE	Iu-ReleaseCommand
50    SUCCESSFUL OUTCOME	Iu-ReleaseComplete
51    PROCEDURE CODE	id-Iu-Release1
52    CRITICALITY		ignore
53    }
54
55relocationPreparation RANAP-ELEMENTARY-PROCEDURE ::= {
56    INITIATING MESSAGE	INTEGER --Iu-ReleaseCommand
57    SUCCESSFUL OUTCOME	Iu-ReleaseComplete
58    PROCEDURE CODE	id-Iu-Release2
59    CRITICALITY		notify
60    }
61
62object3 RANAP-ELEMENTARY-PROCEDURE ::= {
63    &InitiatingMessage Iu-ReleaseCommand,
64    &SuccessfulOutcome Iu-ReleaseComplete,
65    &procedureCode     id-Iu-Release3,
66    &criticality       reject
67    }
68
69object4 RANAP-ELEMENTARY-PROCEDURE ::= {
70    &InitiatingMessage INTEGER,
71    &SuccessfulOutcome PrintableString,
72    &procedureCode     id-Iu-Release4,
73    &criticality       reject
74    }
75
76object5 RANAP-ELEMENTARY-PROCEDURE ::= {
77    &InitiatingMessage INTEGER,
78    &SuccessfulOutcome PrintableString,
79    &Outcome           ProcedureCode,
80    &vartypvalue       12,
81    &infoObject        object4,
82    &InfObjectSet      MyObjectSet,
83    &procedureCode     id-Iu-Release5,
84    &criticality       reject
85    }
86
87
88RANAP-ELEMENTARY-PROCEDURES RANAP-ELEMENTARY-PROCEDURE ::= {
89    iu-Release         |
90    relocationPreparation ,
91    ...
92    }
93
94RANAP-ELEMENTARY-PROCEDURES2 RANAP-ELEMENTARY-PROCEDURE ::= {
95    iu-Release         |
96    relocationPreparation
97    }
98
99
100OBJECTSET1 RANAP-ELEMENTARY-PROCEDURE ::= {
101    {INITIATING MESSAGE Iu-ReleaseCommand SUCCESSFUL OUTCOME Iu-ReleaseComplete PROCEDURE CODE id-Iu-Release1 CRITICALITY ignore} | {INITIATING MESSAGE Iu-ReleaseCommand PROCEDURE CODE id-Iu-Release2}
102    }
103
104OBJECTSET2 RANAP-ELEMENTARY-PROCEDURE ::= {
105    iu-Release |
106    {INITIATING MESSAGE Iu-ReleaseCommand SUCCESSFUL OUTCOME Iu-ReleaseComplete PROCEDURE CODE id-Iu-Release4 CRITICALITY ignore} |
107    relocationPreparation |
108    {INITIATING MESSAGE Iu-ReleaseCommand PROCEDURE CODE id-Iu-Release5} ,
109    ...
110    }
111
112OBJECTSET3 RANAP-ELEMENTARY-PROCEDURE ::= {
113    iu-Release,
114    ...
115    }
116
117OBJECTSET4 RANAP-ELEMENTARY-PROCEDURE ::= {
118    iu-Release
119    }
120
121Iu-ReleaseCommand  ::= SEQUENCE {
122    first     INTEGER,
123    second    BOOLEAN
124    }
125
126Iu-ReleaseComplete ::= INTEGER (1..510)
127
128ProcedureCode      ::= INTEGER (0..255)
129Criticality        ::= ENUMERATED { reject, ignore, notify }
130id-Iu-Release1				INTEGER ::= 1
131id-Iu-Release2				INTEGER ::= 2
132id-Iu-Release3				INTEGER ::= 3
133id-Iu-Release4				INTEGER ::= 4
134id-Iu-Release5				INTEGER ::= 5
135
136--
137-- MY-CLASS
138--
139
140Seq ::= SEQUENCE {
141    int INTEGER,
142    str OCTET STRING
143}
144
145MY-CLASS ::= CLASS {
146    &Count             DEFAULT INTEGER,
147    &integerValue      INTEGER UNIQUE,
148    &booleanValue      BOOLEAN,
149    &stringValue       PrintableString
150}
151
152myobject MY-CLASS ::= {
153    &integerValue      12,
154    &booleanValue      TRUE,
155    &stringValue       "hejsan"
156}
157
158myotherobject MY-CLASS ::= {
159    &Count             Seq,
160    &integerValue      42,
161    &booleanValue      FALSE,
162    &stringValue       "hoppsan"
163}
164
165MyObjectSet MY-CLASS ::= {
166    myobject | myotherobject |
167    {
168        -- Each character will be encoded in 3 bits in UPER, 4 bits in PER.
169	&Count             NumericString (FROM("01234567") ^ SIZE(8)),
170	&integerValue      43,
171	&booleanValue      TRUE,
172	&stringValue       "tjosan"
173    }
174}
175
176MyPdu ::= SEQUENCE {
177    count MY-CLASS.&Count ({MyObjectSet}{@int}),
178    int   MY-CLASS.&integerValue ({MyObjectSet}),
179    bool  MY-CLASS.&booleanValue ({MyObjectSet}{@int}),
180    str   MY-CLASS.&stringValue ({MyObjectSet}{@int})
181}
182
183Seq2 ::= SEQUENCE {
184   int MY-CLASS.&integerValue ({MyObjectSet}),
185   seqof SEQUENCE (1..10) OF MY-CLASS.&booleanValue ({MyObjectSet}{@int}),
186   setof SET (1..10) OF MY-CLASS.&booleanValue ({MyObjectSet}{@int})
187}
188
189--
190-- Class with constructed default
191--
192
193CONSTRUCTED-DEFAULT ::= CLASS {
194  &id INTEGER UNIQUE,
195  &Type DEFAULT SEQUENCE { a INTEGER, b BOOLEAN },
196  &ok BOOLEAN DEFAULT TRUE
197}
198
199constructed1 CONSTRUCTED-DEFAULT ::= { &id 1 }
200constructed2 CONSTRUCTED-DEFAULT ::= { &id 2, &ok false }
201
202ConstructedDefaultSet CONSTRUCTED-DEFAULT ::= {
203  constructed1 |
204  constructed2 |
205  { &id 3, &Type BOOLEAN } |
206  { &id 4, &Type SET { a INTEGER, b BIT STRING } } |
207  { &id 5, &Type CHOICE { i INTEGER, b BIT STRING } } |
208  { &id 6, &Type SEQUENCE OF INTEGER (1..16) } |
209  { &id 7, &Type SET OF INTEGER (1..64) } |
210  { &id 8, &Type SEQUENCE OF SEQUENCE { x INTEGER, y INTEGER } } |
211  { &id 9, &Type SET OF SEQUENCE { x INTEGER, y INTEGER } }
212}
213
214ConstructedPdu ::= SEQUENCE {
215  id CONSTRUCTED-DEFAULT.&id ({ConstructedDefaultSet}),
216  content CONSTRUCTED-DEFAULT.&Type ({ConstructedDefaultSet}{@id})
217}
218
219ConstructedSet ::= SET {
220  id [0] CONSTRUCTED-DEFAULT.&id ({ConstructedDefaultSet}),
221  content [1] CONSTRUCTED-DEFAULT.&Type ({ConstructedDefaultSet}{@id})
222}
223
224-- Test OPTIONAL and DEFAULT
225
226OptionalInSeq ::= SEQUENCE {
227  id CONSTRUCTED-DEFAULT.&id ({ConstructedDefaultSet}),
228  content CONSTRUCTED-DEFAULT.&Type ({ConstructedDefaultSet}{@id}) OPTIONAL
229}
230
231DefaultInSeq ::= SEQUENCE {
232  id CONSTRUCTED-DEFAULT.&id ({ConstructedDefaultSet}),
233  content CONSTRUCTED-DEFAULT.&Type ({ConstructedDefaultSet}{@id})
234          DEFAULT BOOLEAN:TRUE
235}
236
237-- Test more than one optional typefield table constraint in a SEQUENCE.
238
239MULTIPLE-OPTIONALS ::= CLASS {
240   &id INTEGER UNIQUE,
241   &T1,
242   &T2,
243   &T3
244}
245
246multiple-optionals-1 MULTIPLE-OPTIONALS ::=
247   {&id 1, &T1 INTEGER, &T2 BOOLEAN, &T3 OCTET STRING}
248
249Multiple-Optionals-Set MULTIPLE-OPTIONALS ::= {
250   multiple-optionals-1
251}
252
253Multiple-Optionals ::= SEQUENCE {
254   id MULTIPLE-OPTIONALS.&id ({Multiple-Optionals-Set}),
255   t1 [0] MULTIPLE-OPTIONALS.&T1 ({Multiple-Optionals-Set}{@id}) OPTIONAL,
256   t2 [1] MULTIPLE-OPTIONALS.&T2 ({Multiple-Optionals-Set}{@id}) OPTIONAL,
257   t3 [2] MULTIPLE-OPTIONALS.&T3 ({Multiple-Optionals-Set}{@id}) OPTIONAL
258}
259
260-- Test different ways of constructing object sets.
261
262OBJECT-SET-TEST ::= CLASS {
263    &id INTEGER UNIQUE,
264    &Type
265} WITH SYNTAX {
266    &id IS &Type
267}
268
269ObjectSetTest{OBJECT-SET-TEST:ObjectSet} ::=
270  SEQUENCE {
271     id   OBJECT-SET-TEST.&id   ({ObjectSet}),
272     type OBJECT-SET-TEST.&Type ({ObjectSet}{@id})
273  }
274
275ost1 OBJECT-SET-TEST ::= { 1 IS BIT STRING }
276ost2 OBJECT-SET-TEST ::= { 2 IS OCTET STRING }
277ost3 OBJECT-SET-TEST ::= { 3 IS ENUMERATED {donald,scrooge} }
278ost4 OBJECT-SET-TEST ::= { 4 IS BOOLEAN }
279ost5 OBJECT-SET-TEST ::= { 5 IS INTEGER (0..15) }
280
281Ost12    OBJECT-SET-TEST ::= { ost1 | ost2 }
282Ost123   OBJECT-SET-TEST ::= { ost3 | Ost12 }
283Ost1234  OBJECT-SET-TEST ::= { Ost123 | ost4 }
284Ost45    OBJECT-SET-TEST ::= { ost4 | ost5 }
285Ost12345 OBJECT-SET-TEST ::= { Ost123 | Ost45 }
286
287OstSeq12 ::= ObjectSetTest{ {Ost12} }
288OstSeq123 ::= ObjectSetTest{ {Ost123} }
289OstSeq1234 ::= ObjectSetTest{ {Ost1234} }
290OstSeq45 ::= ObjectSetTest{ {Ost45} }
291OstSeq12345 ::= ObjectSetTest{ {Ost12345} }
292
293OstSeq12Except ::= ObjectSetTest{ {Ost123 EXCEPT ost3} }
294OstSeq123Except ::= ObjectSetTest{ {Ost12345 EXCEPT Ost45} }
295
296ExOst1    OBJECT-SET-TEST ::= { ost1, ... }
297ExOst12    OBJECT-SET-TEST ::= { ost1, ..., ost2 }
298ExOst123   OBJECT-SET-TEST ::= { ost3, ..., ExOst12 }
299ExOst1234  OBJECT-SET-TEST ::= { ExOst123, ..., ost4 }
300ExOst45    OBJECT-SET-TEST ::= { ost4, ..., ost5 }
301ExOst12345 OBJECT-SET-TEST ::= { ExOst123, ..., ExOst45 }
302
303ExOstSeq1 ::= ObjectSetTest{ {ExOst1} }
304ExOstSeq12 ::= ObjectSetTest{ {ExOst12} }
305ExOstSeq123 ::= ObjectSetTest{ {ExOst123} }
306ExOstSeq1234 ::= ObjectSetTest{ {ExOst1234} }
307ExOstSeq45 ::= ObjectSetTest{ {ExOst45} }
308ExOstSeq12345 ::= ObjectSetTest{ {ExOst12345} }
309
310ExOstSeq12Except ::= ObjectSetTest{ {ExOst123 EXCEPT ost3} }
311ExOstSeq123Except ::= ObjectSetTest{ {ExOst12345 EXCEPT ExOst45} }
312
313ExInlOst1    OBJECT-SET-TEST ::= {
314    { 1 IS BIT STRING },
315    ...
316}
317ExInlOst12   OBJECT-SET-TEST ::= {
318    { 1 IS BIT STRING },
319    ...,
320    { 2 IS OCTET STRING }
321}
322
323ExInlOstSeq1 ::= ObjectSetTest{ {ExInlOst1} }
324ExInlOstSeq12 ::= ObjectSetTest{ {ExInlOst12} }
325
326--
327-- Test that extensions in a simple class works.
328--
329
330ExtClassSeq ::= SEQUENCE {
331  arg      EXT-CLASS.&id({Extend})
332}
333
334EXT-CLASS ::= CLASS {
335    &id INTEGER UNIQUE
336} WITH SYNTAX {
337    ID &id
338}
339
340Extend EXT-CLASS ::= { { ID alt1 } | { ID alt2 }, ... }
341
342alt1 INTEGER ::= 4
343alt2 INTEGER ::= 5
344
345
346--
347-- Test a BIT STRING which is optional in the simplified syntax.
348--
349
350PUBLIC-KEY ::= CLASS {
351    &id             INTEGER UNIQUE,
352    &keyUsage       KeyUsage OPTIONAL
353} WITH SYNTAX {
354    IDENTIFIER &id
355    [OPTIONAL-BIT-STRING &keyUsage]
356}
357
358KeyUsage ::= BIT STRING {
359     digitalSignature        (0),
360     nonRepudiation          (1),
361     keyEncipherment         (2)
362 }
363
364object-with-optional-bit-string PUBLIC-KEY ::= {
365 IDENTIFIER 42
366 OPTIONAL-BIT-STRING {digitalSignature, nonRepudiation, keyEncipherment}
367}
368
369-- Test object identifiers from objects.
370
371CONTAINER ::= CLASS {
372 &id   OBJECT IDENTIFIER UNIQUE,
373 &rid  RELATIVE-OID OPTIONAL,
374 &Type OPTIONAL
375} WITH SYNTAX {
376  IDENTIFIED BY &id
377  [REL-OID &rid]
378  [TYPE &Type]
379}
380
381id1 OBJECT IDENTIFIER ::= {1 2 42}
382obj1 CONTAINER ::= { IDENTIFIED BY id1 REL-OID {100 101} }
383
384value-2 OBJECT IDENTIFIER ::= { value-1 25 }
385value-1 OBJECT IDENTIFIER ::= obj1.&id
386value-3 RELATIVE-OID ::= obj1.&rid
387value-4 OBJECT IDENTIFIER ::= { 1 2 value-3 }
388
389
390-- Test an obscure issue when ATTRIBUTE.&id was not
391-- properly evaluated.
392
393Rdn ::= SingleAttribute { {SupportedAttributes} }
394
395ATTRIBUTE ::= CLASS {
396   &id             OBJECT IDENTIFIER UNIQUE,
397   &Type           OPTIONAL
398}
399
400SingleAttribute{ATTRIBUTE:AttrSet} ::= SEQUENCE {
401   type      ATTRIBUTE.&id({AttrSet}),
402   value     ATTRIBUTE.&Type({AttrSet}{@type})
403}
404
405AttributeType ::= ATTRIBUTE.&id
406
407SupportedAttributes ATTRIBUTE ::= { at-name }
408
409id-at OBJECT IDENTIFIER ::= { 2 5 4 41 }
410id-at-name AttributeType ::= id-at
411at-name ATTRIBUTE ::= { &Type PrintableString, &id id-at-name }
412
413--
414-- Test using an alias for TYPE-IDENTIFIER.
415--
416
417TiAliasParameterized { TI-ALIAS:InfoObjectSet } ::= SEQUENCE {
418  algorithm TI-ALIAS.&id({InfoObjectSet}),
419  parameters TI-ALIAS.&Type({InfoObjectSet} {@algorithm}) OPTIONAL
420}
421
422TI-ALIAS ::= TYPE-IDENTIFIER
423
424TiAliasSeq ::= SEQUENCE {
425  prf TiAliasParameterized {{TiAliasSet}}
426}
427
428TiAliasSet TI-ALIAS ::= {
429  {NULL IDENTIFIED BY {2 1 2}},
430   ...
431}
432
433--
434-- Test using an alias for a class.
435--
436
437ALIAS-CONTAINER ::= CLASS {
438  &id INTEGER UNIQUE,
439  &obj INDIRECT-CLASS
440}
441
442INDIRECTED-CLASS ::= CLASS {
443  &id INTEGER UNIQUE,
444  &Type
445}
446
447INDIRECT-CLASS ::= INDIRECTED-CLASS
448
449--
450-- Indirect ObjectClassFieldType in a SEQUENCE.
451--
452
453ContentInfo ::= SEQUENCE {
454  contentType  ContentType, -- Indirect ObjectClassFieldType
455  content      TYPE-IDENTIFIER.&Type({Contents}{@contentType})
456OPTIONAL
457}
458
459Contents TYPE-IDENTIFIER ::= {
460  {IA5String IDENTIFIED BY id-content-type}
461}
462
463ContentType ::= TYPE-IDENTIFIER.&id({Contents})
464id-content-type ContentType ::= { 2 7 8 9 }
465
466--
467-- Tricky parsing of simplified syntax.
468--
469
470TrickyType-1 ::= BIT STRING
471TrickyType-2 ::= OCTET STRING
472
473TRICKY ::= CLASS {
474  &Type1,
475  &Type2
476} WITH SYNTAX {
477   TYPE &Type1 &Type2
478}
479
480tricky-object TRICKY ::= {TYPE TrickyType-1 TrickyType-2}
481
482tricky-bit-string tricky-object.&Type1 ::= '1011'B
483tricky-octet-string tricky-object.&Type1 ::= 'CAFE'H
484
485END
486