path: root/third_party/heimdal/lib/asn1/test.asn1

-- $Id$ --

TEST DEFINITIONS ::=

BEGIN

IMPORTS HEIM_ANY FROM heim;

-- Check that we handle out of order definitions.
-- The compiler should emit the definition of TESTOutOfOrderBar before that of
-- TESTOutOfOrderFoo.
TESTOutOfOrderFoo ::= SEQUENCE {
        bar TESTOutOfOrderBar
}

TESTOutOfOrderBar ::= SEQUENCE {
        aMember INTEGER
}

-- Check that we can handle rpc.mountd style "lists".  This is unnecessarily
-- inefficient in its encoding, and there's no point to using this over
-- SEQUENCE OF (arrays), but it's neat that we can do this now that we can do
-- out of order definitions.
--
-- This could be useful if we ever extend asn1_compile to also handle XDR,
-- which we well might since XDR's syntax is a dual of a strict subset of
-- ASN.1, and since XDR the encoding is fairly straightforward.
--
-- Note that the `next' member has to be OPTIONAL for this to work.
TESTCircular ::= SEQUENCE {
        name UTF8String,
        next TESTCircular OPTIONAL
}

TESTDefault ::= SEQUENCE {
        name UTF8String DEFAULT "Heimdal",
        version [0] TESTuint32 DEFAULT 8,
        maxint TESTuint64 DEFAULT 9223372036854775807,
        works BOOLEAN DEFAULT TRUE
}

TESTuint32 ::= INTEGER (0..4294967295)
TESTuint64 ::= INTEGER(0..9223372036854775807)
TESTint64 ::= INTEGER(-9223372036854775808..9223372036854775807)

TESTLargeTag ::= SEQUENCE {
	foo[127] INTEGER (-2147483648..2147483647),
	bar[128] INTEGER (-2147483648..2147483647)
}

TESTSeq ::= SEQUENCE {
	tag0[0] INTEGER (-2147483648..2147483647),
	tag1[1] TESTLargeTag,
	tagless INTEGER (-2147483648..2147483647),
	tag3[2] INTEGER (-2147483648..2147483647)
}

TESTChoice1 ::= CHOICE {
	i1[1]	INTEGER (-2147483648..2147483647),
	i2[2]	INTEGER (-2147483648..2147483647),
	...
}

TESTChoice2 ::= CHOICE {
	i1[1]	INTEGER (-2147483648..2147483647),
	...
}

TESTInteger ::= INTEGER (-2147483648..2147483647)

TESTInteger2 ::= [4] IMPLICIT TESTInteger
TESTInteger3 ::= [5] IMPLICIT TESTInteger2

TESTImplicit ::= SEQUENCE {
	ti1[0] IMPLICIT INTEGER (-2147483648..2147483647),
	ti2[1] IMPLICIT SEQUENCE {
		foo[127] INTEGER (-2147483648..2147483647)
	},
	ti3[2] IMPLICIT [5] IMPLICIT [4] IMPLICIT INTEGER (-2147483648..2147483647)
}

TESTImplicit2 ::= SEQUENCE {
	ti1[0]  IMPLICIT TESTInteger,
--	ti2[1]  IMPLICIT TESTLargeTag,   this is disabled since the IMPLICT encoder does't get the types right when stepping inside an structure --
	ti3[2]  IMPLICIT TESTInteger3,
        ti4[51] IMPLICIT TESTInteger OPTIONAL
}

TESTImplicit3 ::= CHOICE {
        ti1[0] IMPLICIT INTEGER (-2147483648..2147483647),
        ti2[5] IMPLICIT CHOICE { i1[1] INTEGER (-2147483648..2147483647) }
}

TESTImplicit4 ::= CHOICE {
        ti1[0] IMPLICIT INTEGER (-2147483648..2147483647),
        ti2[5] IMPLICIT TESTChoice2
}

TESTAllocInner ::= SEQUENCE {
	ai[0] TESTInteger
}

TESTAlloc ::= SEQUENCE {
	  tagless TESTAllocInner OPTIONAL,
	  three [1] INTEGER (-2147483648..2147483647),
	  tagless2 HEIM_ANY OPTIONAL
}

TESTOptional ::= SEQUENCE {
	  zero [0] INTEGER (-2147483648..2147483647) OPTIONAL,
	  one [1] INTEGER (-2147483648..2147483647) OPTIONAL
}


TESTCONTAINING ::= OCTET STRING ( CONTAINING INTEGER )
TESTENCODEDBY ::= OCTET STRING ( ENCODED BY
  { joint-iso-itu-t(2) asn(1) ber-derived(2) distinguished-encoding(1) }
)

testDer OBJECT IDENTIFIER ::= {
	joint-iso-itu-t(2) asn(1) ber-derived(2) distinguished-encoding(1)
}

testContainingEncodedBy ::= OCTET STRING ( CONTAINING INTEGER ENCODED BY
  { joint-iso-itu-t(2) asn(1) ber-derived(2) distinguished-encoding(1) }
)

testContainingEncodedBy2 ::= OCTET STRING (
	CONTAINING INTEGER ENCODED BY testDer
)


testValue1 INTEGER ::= 1

testUserConstrained ::= OCTET STRING (CONSTRAINED BY { -- meh -- })
-- TESTUSERCONSTRAINED2 ::= OCTET STRING (CONSTRAINED BY { TESTInteger })
-- TESTUSERCONSTRAINED3 ::= OCTET STRING (CONSTRAINED BY { INTEGER })
-- TESTUSERCONSTRAINED4 ::= OCTET STRING (CONSTRAINED BY { INTEGER : 1 })

TESTSeqOf ::= SEQUENCE OF TESTInteger

TESTSeqSizeOf1 ::= SEQUENCE SIZE (2) OF TESTInteger
TESTSeqSizeOf2 ::= SEQUENCE SIZE (1..2) OF TESTInteger
TESTSeqSizeOf3 ::= SEQUENCE SIZE (1..MAX) OF TESTInteger
TESTSeqSizeOf4 ::= SEQUENCE SIZE (0..2) OF TESTInteger

TESTOSSize1 ::= OCTET STRING SIZE (1..2)

TESTSeqOfSeq ::= SEQUENCE OF SEQUENCE {
	zero [0] TESTInteger
}

TESTSeqOfSeq2 ::= SEQUENCE OF SEQUENCE {
	string [0] GeneralString
}

TESTSeqOfSeq3 ::= SEQUENCE OF SEQUENCE {
	zero [0] TESTInteger,
	string [0] GeneralString
}

TESTSeqOf2 ::= SEQUENCE {
	strings SEQUENCE OF GeneralString
}

TESTSeqOf3 ::= SEQUENCE {
	strings SEQUENCE OF GeneralString OPTIONAL
}

-- Larger/more complex to increase odds of out-of-bounds
-- read/writes if miscoded

TESTSeqOf4 ::= SEQUENCE {
	b1 [0] SEQUENCE OF SEQUENCE {
		s1 OCTET STRING,
		s2 OCTET STRING,
		u1 TESTuint64,
		u2 TESTuint64
	} OPTIONAL,
	b2 [1] IMPLICIT SEQUENCE OF SEQUENCE {
		u1 TESTuint64,
		u2 TESTuint64,
		u3 TESTuint64,
		s1 OCTET STRING,
		s2 OCTET STRING,
		s3 OCTET STRING
	} OPTIONAL,
	b3 [2] IMPLICIT SEQUENCE OF SEQUENCE {
		s1 OCTET STRING,
		u1 TESTuint64,
		s2 OCTET STRING,
		u2 TESTuint64,
		s3 OCTET STRING,
		u3 TESTuint64,
		s4 OCTET STRING,
		u4 TESTuint64
	} OPTIONAL
}

TESTSeqOf5 ::= SEQUENCE {
        outer SEQUENCE {
          inner SEQUENCE {
                        u0 TESTuint64,
                        s0 OCTET STRING,
                        u1 TESTuint64,
                        s1 OCTET STRING,
                        u2 TESTuint64,
                        s2 OCTET STRING,
                        u3 TESTuint64,
                        s3 OCTET STRING,
                        u4 TESTuint64,
                        s4 OCTET STRING,
                        u5 TESTuint64,
                        s5 OCTET STRING,
                        u6 TESTuint64,
                        s6 OCTET STRING,
                        u7 TESTuint64,
                        s7 OCTET STRING
                }
            }
        OPTIONAL
}

TESTPreserve ::= SEQUENCE {
	zero [0] TESTInteger,
	one [1] TESTInteger
}

TESTBitString ::= BIT STRING {
	      zero(0),
	      eight(8),
	      thirtyone(31)
}

TESTBitString64 ::= BIT STRING {
	      zero(0),
	      eight(8),
	      thirtyone(31),
	      thirtytwo(32),
	      sixtythree(63)
}

TESTLargeBitString ::= BIT STRING {
	      zero(0),
	      eight(8),
	      thirtyone(31),
	      onehundredtwenty(120)
}

TESTMechType::= OBJECT IDENTIFIER
TESTMechTypeList ::= SEQUENCE OF TESTMechType


-- IOS stuff
_EXTENSION ::= CLASS {
    &id  OBJECT IDENTIFIER UNIQUE,
    &ExtnType,
    &Critical    BOOLEAN DEFAULT FALSE
}

TESTExtension{_EXTENSION:ExtensionSet} ::= SEQUENCE {
    extnID      _EXTENSION.&id({ExtensionSet}),
    critical    BOOLEAN
--                     (EXTENSION.&Critical({ExtensionSet}{@extnID}))
                     DEFAULT FALSE,
    extnValue   OCTET STRING (CONTAINING
                _EXTENSION.&ExtnType({ExtensionSet}{@extnID}))
}

id-test-default OBJECT IDENTIFIER ::=  { 1 2 3 4 }
testext-TESTDefault _EXTENSION ::= {
     &id id-test-default,
     &Critical FALSE,
     &ExtnType TESTDefault
}

-- And Here's an object set for the EXTENSION CLASS collecting a bunch of
-- related extensions (here they are the extensions that certificates can
-- carry in their extensions member):
TestExtensions _EXTENSION ::= { testext-TESTDefault }

TESTExtension ::= TESTExtension { TestExtensions }

TESTExtensible ::= SEQUENCE {
  version     INTEGER,
  extensions  SEQUENCE OF TESTExtension
}

TESTDecorated ::= SEQUENCE {
  version     TESTuint32
  -- gets decorated with varius fields (see test.opt)
}

TESTNotDecorated ::= SEQUENCE {
  version     TESTuint32
  -- should have the same encoding as TESTDecorated
}

TESTDecoratedChoice ::= CHOICE {
  version     TESTuint32
  -- gets decorated with varius fields (see test.opt)
}

TESTNotDecoratedChoice ::= CHOICE {
  version     TESTuint32
  -- should have the same encoding as TESTDecoratedChoice
}

END