Note that this document contains the OBJECTIVE section of each Ada 95 test. None of the legacy tests are included. B330001 Check that if a subtype indication of a variable object defines an indefinite subtype, then there is an initialization. Check that if the array type definition of a variable object defines an unconstrained array subtype, then there is an initialization. Check that indefinite subtypes may not be used as the subtype indication of a component definition (in either an array or a record definition). B354001 Check that the expression of a modular_type_definition must be static and that the expected type of the expression can be of any integer type. Check that the modulus must be positive. Check that moduli that are powers of two are allowed up to and including, but not exceeding, System.Max_Binary_Modulus. Check that non-power-of-two moduli are allowed as long as they do not exceed System.Max_Nonbinary_Modulus. Check that the value of a potentially static expression of a modular type that appears in a nonstatic context must be within the base range of its expected type. Check that the predefined logical operators and membership tests are available. B360001 Check that, within the definition of a nonlimited composite type or a limited composite type that becomes nonlimited later in its immediate scope, if a component definition contains the reserved word aliased and the type of the component is discriminated, the nominal subtype of the component may not be unconstrained. B370001 Check that a discriminant specification for an access discriminant may not appear in the declaration of a type (that is not a task or protected type) if the word limited does not appear in the definition of the type or in that of one of its ancestors. Check for basic cases, including a type that is limited only due to the presence of a limited component. Check for the generic case, where the type is derived from a nonlimited tagged formal private type, or a formal private extension. Check for the instance case, where the type is derived from a limited tagged formal private type, and the corresponding actual is not limited. Check in both the visible and private part of an instance, using record and private extensions. B370002 Check that for derived types with known discriminant parts the parent subtype must be constrained; if the parent type is not tagged, each discriminant of the new type must be used in the constraint defining the parent subtype; and, if a discriminant is used in the constraint defining the parent subtype, the subtype of that discriminant must be statically compatible with the subtype of the corresponding parent discriminant. B371001 Check that a discriminant_constraint of a general access type is illegal if there is a place within the immediate scope of the designated subtype where the designated subtype's view is unconstrained. (Defect Report 8652/0008, as reflected in Technical Corrigendum 1). B380001 Check that the name of a non-inherited discriminant can be the same as the name of a newly added component. Check that the name of the current instance of a type used to define the constraint of a component may only be used as a direct_name that is the prefix of an attribute_reference whose result is of an access type, and that the attribute_reference must appear alone. Check that the name of a non-inherited discriminant is not allowed within the discriminant part. B390001 Check that: Class wide objects are required to be initialized (whether created by object declaration or an allocator). Aggregates of a class wide type are required to be qualified with a specific type when their expected type is class-wide. Tagged private and tagged limited private require the full type to be a tagged record type. The attribute 'Class is not defined for untagged types. The Class attribute is defined for untagged private types whose full type is tagged, but only in the private part of the package in which the type is declared. B391001 Check that: A discriminant on a tagged type is not allowed to have a default. Private record extension is not allowed to be declared immediately within a subprogram declarative region. Record extension of a nonlimited type does not allow limited components. A record extension may not be declared in a nested package where it is not accessible from the declaration of its parent type. Record extension does not allow repeating identifiers used in the parent declaration. B391002 Check that a type extension may not be declared in a generic body if the parent type is declared outside that body. B391003 Check that the parent type of a record extension may not be a class-wide type. Check for the basic case. Check for the generic case, where the parent type is the class-wide type of a formal tagged private type or formal private extension. Check for the instance case, where the parent type is a formal tagged private type or formal private extension, and the corresponding actual type is a class-wide type. Check that this rule is enforced in the visible and private part of an instance. B391004 Check that if a (non-derived) tagged type has any limited components, the reserved word limited must appear in its definition. Check for basic and generic cases. Check that if the parent type of a record extension is nonlimited, each of the components of the record extension part must be nonlimited. Check for generic declarations and instances. B392001 Check that a default_expression for a controlling formal parameter of a dispatching operation may not be statically tagged. Check that a controlling formal parameter that is an access parameter may not have a default_expression. B392002 Check that a subprogram may not be a dispatching operation for two distinct tagged types (in a package). B392003 Check that: A dispatching operation which overrides an inherited subprogram is required to be subtype conformant with the inherited subprogram. The declaration of dispatching operations does not allow the use of subtypes which do not statically match the first subtype of the tagged type (in a package). B392004 Check that: A dynamically tagged value is not allowed in an object or expression for which the expected type is a specific tagged value (unless it is a controlling operand on a dispatching operation). An access-to-classwide type is not allowed in an expression for which the expected type is an anonymous access to specific type (unless it is a controlling operand on a dispatching operation). A call on dispatching operation may not have both dynamically tagged and statically tagged controlling operands. B392005 Check that a subprogram may not be a dispatching operation for two different tagged types (in a child unit package). B392006 Check that a default_expression for a controlling formal parameter of a dispatching operation must be tag indeterminate. Specifically, check that it may not be dynamically tagged. B392007 Check that a dispatching operation declared in a child package which overrides an inherited subprogram declared in parent is required to be subtype conformant with the inherited subprogram. B392008 Check that a subprogram call through a dereference of an access-to- subprogram value is not considered a call on a dispatching operation; therefore, the actual parameter in such a subprogram call may not be dynamically tagged. Check for the case where the access-to-subprogram type is a generic formal type. B392009 Check that a subprogram call through a dereference of an access-to- subprogram value is not considered a call on a dispatching operation; therefore, the actual parameter in such a subprogram call may not be dynamically tagged. Check that a designated profile of an access-to-subprogram type which contains parameters of a tagged type does not introduce a primitive operation of the tagged type. B392010 Check that a primitive operation of two tagged types is illegal, even when the types are not known to be tagged at the place where the operation is declared. This was confirmed by AI-00183. B393001 Check that: Objects and aggregates may not be defined or allocated of an abstract type. The type of a component may not be abstract. A function defined with an abstract result type must be declared abstract. If an abstract subprogram is defined as a primitive subprogram of a a tagged type, then the tagged type must be abstract. The full type of a non-abstract private extension may not be abstract. The full type of an abstract private extension may be non-abstract. B393002 Check that incorrect orderings of reserved words in a tagged type declaration are flagged as illegal. B393003 Check that: Bodies are not allowed for abstract subprograms. An abstract subprogram defined using a combination of concrete and abstract types remains abstract upon derivation from the concrete type. The target of an assignment operation may not be abstract. Subprogram bodies in a package body that are homographs of inherited primitive abstract operations are illegal. B393004 Check that the actual subprogram corresponding to a generic formal subprogram must not be abstract. B393005 Check that an abstract type derived from a tagged parent may override primitive functions with controlling results as abstract. Check that an abstract type derived from a tagged parent may not override primitive functions with controlling results as not abstract. Check that when a non-abstract or untagged type is derived from a tagged parent with a primitive function returning a controlling result, the function with the controlling result must be overridden. Check that an abstract private type may not have a primitive abstract subprogram if the full view of the type is not abstract. B393006 Check that, if a non-abstract type is derived from an abstract formal private type within the generic declaration, an instantiation is rejected if the derived type inherits abstract primitive subprograms from the actual (parent) type. B393007 Check that abstract primitive subprograms for an abstract type declared in a visible part are not allowed in the private part (unless they are overriding an inherited subprogram). Check that primitive functions with controlling results for a tagged type declared in a visible are not allowed in the private part (unless they are overriding an inherited subprogram). Check that a subprogram that must be overridden with a nonabstract subprogram cannot be renamed. (This was the conclusion of AI-211). B3A0001 Check that objects defined to be of a general access type may not designate an object or component which is not defined to be aliased. Check that a renaming of an aliased view is also defined to be aliased. Check that an array slice may not be aliased. Check that the general access modifiers "all" and "constant" are allowed. Check that an object designated by an access-to-constant type object cannot be updated through a value of that type. Check that an object designated by a value of an access-to-variable type can be both read and updated. B3A0002 Check that subtype conformance is required for actual values of access to subprogram types. Check that the mode, number and subtype of parameters must statically match. Check that the calling convention of the value must not be Intrinsic. Check that corresponding subtypes of the profiles must statically match. Check that a generic formal subprogram may not be the actual value of an access to subprogram type because it cannot subtype-conform with anything. B3A0003 Check that a designated object cannot be updated through a value of an access-to-constant type. Check for the cases where the access-to- constant type is a generic formal type, or a non-formal type declared within a formal package. B3A0004 For an array object X used as the prefix for the attributes X'Access or X'Unchecked_Access, where the expected type for X'Access or X'Unchecked_Access is the general access type A: Check that the nominal subtype of an aliased view of X must statically match A's designated array subtype. B3A2002 Check that: 'Access is not defined for non-aliased objects. For X'Access of a general access type A, if A is an access-to-constant type, X can be either a constant or a variable. For X'Access of a general access type A, if A is an access-to-variable type, X must denote the view of a variable. Check for cases where X is a: (a) Formal in parameter of a tagged type. (b) Generic formal in parameter of a tagged type. (c) Formal in parameter of a composite type with aliased components. (d) Function return value of a composite type with aliased components. B3A2003 Check that, for X'Access of a general access type A, the accessibility level of the view denoted by X must not be statically deeper than that of the access type A. Check for cases where X is: (a) a view denoted by an object declaration. (b) a view denoted by a component definition. (c) a formal parameter of a tagged type. B3A2004 Check that, for X'Access of a general access type A, the accessibility level of the view denoted by X must not be statically deeper than that of the access type A. Check for cases where X is: (a) a renaming of an aliased view. (b) a dereference of an access-to-object value. (c) a view conversion of an aliased view. B3A2005 Check that, for X'Access of a general access type A, the accessibility level of the view denoted by X must not be statically deeper than that of the access type A. Check for the case where A is an anonymous access type, and X'Access is used to initialize an access discriminant of an object created by an allocator. B3A2006 Check that, for P'Access of an access-to-subprogram type S, the accessibility level of the subprogram denoted by P must not be statically deeper than that of S. B3A2007 Check that, for X'Access of a general access type A, the accessibility level of the view denoted by X must not be statically deeper than that of A. Check for cases where X'Access occurs in the visible part of an instance and X is declared in the instance itself. Check for cases where X is: (a) a view defined by an object declaration. (b) a renaming of an aliased view. (c) a view conversion of an aliased view. B3A2008 Check that, for X'Access of a general access type A, the accessibility level of the view denoted by X must not be statically deeper than that of A. Check for cases where X'Access occurs in the private part of an instance and X is declared in the instance itself. Check for cases where X is: (a) a view defined by an object declaration. (b) a view defined by a component definition. (c) a dereference of an access-to-object value. B3A2009 Check that, for P'Access of an access-to-subprogram type S, if the subprogram denoted by P is declared within a generic body, S must also be declared within the generic body. B3A2010 Check that, for P'Access of an access-to-subprogram type S, the accessibility level of the subprogram denoted by P must not be statically deeper than that of S. Check for cases where P'Access occurs in the visible and private part of an instance. B3A2011 Check that, for X'Access of a general access type A, the accessibility level of the view denoted by X must not be statically deeper than that of A. Check for cases where X'Access occurs in the private part of an instance and X is passed as an actual during instantiation. Check for cases where X is: (a) a view defined by an object declaration. (b) a renaming of an aliased view. (c) a view conversion of an aliased view. B3A2012 Check that, for X'Access of a general access type A, the accessibility level of the view denoted by X must not be statically deeper than that of A. Check for cases where X'Access occurs in the visible part of an instance and X is passed as an actual during instantiation. Check for cases where X is: (a) a view defined by an object declaration. (b) a view denoted by a component definition. (c) a dereference of an access-to-object value. B3A2013 Check that, for X'Access of a general access type A, the accessibility level of the view denoted by X must not be statically deeper than that of the access type A. Check for cases where X is: (a) a current instance of a limited type. (b) a current instance of a limited type in a type conversion. B3A2014 Check that, for X'Access of a general access type A, if the designated type is tagged, the type of the view denoted by X must be covered by the designated type. Check that if the designated type is not tagged, the type of the view must be the same, and either A's designated subtype must statically match the nominal subtype of the view, or the designated subtype must be discriminated and unconstrained. B3A2015 Check that, for X'Access of a general access type A, the view denoted by X must not be a subcomponent that depends on discriminants of a variable whose nominal subtype is unconstrained, unless this subtype is indefinite, or the variable is aliased. Check that, for a renaming of an object, the renamed entity must not be a subcomponent that depends on discriminants of a variable whose nominal subtype is unconstrained, unless this subtype is indefinite, or the variable is aliased. Check that if the view denoted by X is that of a subcomponent of an aliased composite object, the word aliased must appear in the subcomponent's component definition. Check for objects which are declared aliased, objects created by an allocator, and formal parameters of a tagged type. B3A2016 Check that the type of the prefix of X'Access is not used to resolve the expected type (both for X as an object and as a subprogram). Check that different access-to-subprogram type with the same accessed profile do not match. B420001 Check that if the index subtype of a string type is a modular subtype whose lower bound is zero, then the evaluation of a null string_literal raises Constraint_Error. This was confirmed by AI95-00138. Note: If the null string_literal is a static expression (which is usual), then the Constraint_Error does not happen at run time, but is caught at compile time by RM-4.9(34). B430001 Check that an aggregate may not be of a class-wide type. Check that "null record" may appear as a record component association list in record aggregates and extension aggregates. Check that if no components are needed in a record component association list, "null record" must appear, and that if components are needed, "null record" must not appear. B455002 Check that a universal fixed multiplying operator cannot be used in a context where the result type is univeral fixed. B460001 Check that if the target type of a type conversion is a general access type, the accessibility level of the operand type must not be statically deeper than that of the target type. Check for cases where the operand is: (a) a stand-alone access object. (b) a formal parameter. (c) an access discriminant. B460002 Check that if the target type of a type conversion is a general access type, the accessibility level of the operand type must not be statically deeper than that of the target type. Check for cases where the type conversion occurs in the visible or private part of an instance. B460004 Check that if the target type of a type conversion is tagged, the operand type must be covered by or descended from the target type, or the operand type must be a class-wide type that covers the target type. Check that if the target designated type of a general access type conversion is tagged, the operand designated type must be convertible to the target designated type. B460005 Check that in a view conversion of arrays, the target and operand components may not have different aliasing (that is, if one has aliased components the other must have aliased components, and vice versa) (Defect Report 8652/0008). B480001 Check that if the subtype indication of an uninitialized allocator specifies an access type, no explicit constraint is permitted. B490001 Check that the following are static expressions: (a) A numeric literal whose expected type is not a static subtype. (b) A string literal of a static string subtype. (c) X'First, X'Last, or X'Length, where X statically denotes a statically constrained array object or array subtype. (d) A type conversion whose subtype mark denotes a static scalar subtype, and whose operand is a static expression. (e) A membership test whose simple expression is a static expression, and whose range is a static range or whose subtype mark denotes a static subtype. (f) A short-circuit control form both of whose relations are static expressions. Check that the Range attribute of a statically constrained array subtype or object gives a static range. Check that a predefined concatenation operator whose result type is a string type is a static function. Check that a static expression is illegal if its evaluation fails a language-defined check other than Overflow_Check, even if it is part of a larger static expression. Check that B490002 Check that a static string expression that is the result of a catenation is illegal if it has length greater than that permitted by the expected type. Check that it is illegal to assign a null string literal to an object whose lower bound is equal to the lower bound of the base range of the index type. B610001 Check that access parameters may have default expressions. Check that the expected type of the actual access parameter is the nominal subtype of the formal anonymous access parameter. B641001 Check that the actual parameter corresponding to a formal parameter of mode in out or out must denote a variable; in particular, that it may not be a dereference of an access-to-constant value. Check for the cases where the value is of a generic formal access-to-constant type, or of a non-formal access-to-constant type declared within a formal package. B660001 Check that the "=" operator may be overloaded for non-limited private types. Check that explicit overloadings of "/=" may not have a Boolean result. Check that the result of an explicitly declared "=" operator may be other than Boolean. Check that an equality operator may rename a function other than an equality operator. B660002 Check that the "=" operator may be overloaded for non-limited types. Check that explicit overloadings of "/=" may not have a Boolean result. Check that the result of an explicitly declared "=" operator may be other than Boolean. Check that an equality operator may rename a function other than an equality operator. Check that a declaration of "=" whose result type is not Boolean does not implicitly declare a "/=" operation that gives the complementary result. B720001 Check that if a library package declaration or library generic package declaration does not require a body, that a body is not allowed. Check that pragma Elaborate_Body can be used to require a body even if not otherwise required. B730001 Check that: Full type of a tagged private type must be a tagged type. This means that the full type must either be declared using a tagged record definition, or else derived from some other tagged type, in which case it must include a record_extension_part. Full type of a nonlimited tagged private type must be a nonlimited tagged type. Full type of a limited tagged private type must be a limited tagged type. A tagged record type must be a limited type if one of its record components is limited. A record extension must be extended from a limited parent type if one of its record components is limited. B730002 Check that a private extension is limited if its ancestor type is limited. Check that if a partial view is nonlimited, the full view must be nonlimited. Check that if a partial view of a tagged type is limited, the full view must be limited, but that if a partial view of an untagged type is limited, the full view may be either limited or nonlimited. Check that the full view of a private extension must be derived, either directly or indirectly, from the ancestor type. Check that the ancestor type of a private extension must be a specific type. B730003 Check that if the partial view of a private type is tagged, the full view must be tagged. Check that if the partial view of a private type is untagged, the full view may be tagged or untagged, but that if the partial view is untagged and the full view is tagged, no derivatives of the partial view are allowed within the immediate scope of the partial view. Check that derivatives of the full view are allowed. B730004 Check that if a public child is "with"ed by a client, the client does not have visibility into the private part of the child's parent. Check that the full view of a private type defined in a parent and extended in a child is not visible outside the child. B730005 Check that the ancestor type of a private extension may not be a class-wide type. Check for the basic case. Check for the generic case, where the ancestor type is the class-wide type of a formal tagged private type or formal private extension. Check for the instance case, where the ancestor type is a formal (tagged or untagged) private type or formal private extension, and the corresponding actual type is a class-wide type. Verify this rule in the visible and private part of an instance. In the private part, check specifically for the case where the parents of the partial and full views are different. B730006 Check that the visible components of a type extension are only those inherited from the parent type, even if additional components of an ancestor type are visible. B731001 Check the requirements of 7.3.1 for inheritance of characteristics and primitive operations, including characteristics and operations that become available later in the declarative part. The test cases here are inspired by the AARM examples given in AARM-7.3.1(7.a-7.v). B731A01 Check that the inherited primitive subprograms of a derived type definition are implicitly declared at the earliest place within the immediate scope of the type declaration (but after the type declaration) where the corresponding declaration from the parent is visible. Check that, within its scope, the full view determines which components are visible. Check for the cases where the parent is a partial view (tagged private type) declared in a package, and the derived type is declared in: the visible part of a public child unit a package nested within the visible part of a public child unit B731A02 Check that the inherited primitive subprograms of a derived type are implicitly declared at the earliest place within the immediate scope of the type declaration (but after the type declaration) where the corresponding declaration from the parent is visible. Check that, within its scope, the full view determines which components are visible. Check for the cases where the parent is a partial view (tagged private type) declared in a package, and the derived type is declared in: the visible part of a private child unit a package nested within the visible part of a private child unit a non-child package, and is further derived from in a child unit a package nested within the visible part of a public child unit B740001 Check that a deferred constant may be declared of any type and that, if it is completed by a full constant declaration, its completion must occur immediately within the private part of the same package. Check that the deferred and full constants must have the same type. B810001 Check that a choice_parameter_specification in an exception handler hides outer declarations with the same name. Check that two choice parameters within exception handlers of the same handled_sequence_of_statements can have the same name. Check that a choice_parameter_specification in an exception handler is not visible outside the handler. B830001 Check that two homographs are not allowed to be declared explicitly immediately within the same declarative region. Check for cases of child package names. Check for cases of dispatching operations declared in the visible part of an instance. B830002 Check the requirements of the modified 8.3(26) from Technical Corrigendum 1 (originally discussed as AI95-00150). For a type extension declared in a child package, where the parent type is declared in an ancestor package, it is illegal for the two types to have duplicate component names. B840001 Check that the name in a use type clause must denote a subtype. Check that only the primitive operators of the type determined by the subtype mark in a use type clause are use-visible (in particular, that the primitive operators of no other type declared in the same package are use-visible). Check that the scope of a use type clause in the private part of a library unit does not include the visible part of any public descendant of that library unit. B851001 Check that the restrictions on renaming components that depend on a discriminant are enforced in the public and private parts of an instance. Check that the restrictions on renaming components that depend on a discriminant are enforced in the body of a generic unit. Include the decendant of an untagged generic formal derived type case. (Defect Report 8652/0017, Technical Corrigendum 8.5.1(5/1)). B854001 Check that a renaming-as-body is illegal if the declaration occurs before the subprogram it completes is frozen, and the renaming renames the subprogram itself. (Defect Report 8652/0027, as reflected in Technical Corrigendum 1). B940001 Check that a protected_element_declaration within the private part of a protected type must be a component_declaration (if it is not a protected_operation_declaration). Specifically: an anonymous array is not allowed B940002 Check that a protected_element_declaration within the private part of a protected type must be a component_declaration (if it is not a protected_operation_declaration). Specifically: a constant component is not allowed a type declaration is not allowed B940003 Check that protected declarations (in a normal procedure) require completion by a protected body and vice versa. B940004 Check that protected declarations (in a package) require completion by a protected body and vice versa. B940005 Check the visibility of local subprograms and the private parts of protected objects B940006 Check that component declarations are only allowed in the private part of protected objects B940007 Check that component declarations are not allowed in the body of protected objects B951001 Check that the body of a protected function cannot have an internal call to a protected procedure. B952001 Check that the name that denotes the formal parameter of an entry body is not allowed within the entry barrier B952002 Check that the body of a protected entry must have an entry barrier. Check that if an entry identifier appears at the end of an entry body it repeats the defining identifier of the entry or the entry family B952003 Check that, in the body of a protected entry, the entry_index_specification must be enclosed in parentheses. B952004 Check that an entry_declaration in a task declaration cannot contain a specification for an access parameter. Check that an accept_statement is not allowed within an asynchronous_select inner to the enclosing task_body. B954001 Check for error if requeue is not type conformant with the call or if requeue has parameters. Check requeues with/without abort. B954003 Check that the accessibility level of the target task object of a requeue_statement is not equal to or statically deeper than any enclosing accept_statement of the task unit. Check that for a requeue statement of an entry_body the target object is either a formal parameter of the entry_body or the accessibility level of the target object is not statically deeper that that of the entry_declaration. B954004 Check that a requeue_statement is only allowed directly within an entry_body or accept_statement. B960001 Check that an argument to the delay_until_statement must have type Calendar.Time. In particular check that the delay_expressions of Duration, Float and Integer are flagged as errors BA11001 Check that in the visible part of a public child, the private declarations of the parent package are not visible. BA11002 Check that the private declarations of the parent are not visible for a formal parameter list or result type of a public child. BA11003 Check that a child library unit may not have anything other than a library package or generic library package as its parent unit. Check that nested units cannot have child units. Check that child of a generic package may not be anything other than a generic unit or a renaming of some other child of the same generic unit. Check that a child of an instance of a generic package must be an instance or a renaming of a library unit. BA11004 Check that a child library subprogram is not primitive subprogram (i.e, is not inherited by types derived from a type declared in the parent). BA11005 Check that a parent body cannot declare a homograph of the child when a child unit is included in the context clause of the parent body. BA11007 Check that a child library subprogram may not override a user-defined primitive subprogram. BA11008 Check that an instance of a child of a generic package that is not part of a formal package declaration and that is a child of an instance of the generic package is not allowed outside the declarative region of the generic package itself. Check that an instance of a generic does not inherit children from the generic. Check that a child of an instance of a generic package must be an instance. BA11009 Check that if the generic being renamed is itself a child of a generic package P, the renaming must occur in a place that is within the declarative region of P, which includes the body, the children (and descendant ...), and the subunits of P. BA11010 Check that a library unit renaming declaration may not be used to rename a physically nested package, a physically nested subprogram, or a subunit. BA11011 Check that the renamed entity must be a generic unit of the appropriate kind. Check that in a library_unit_renaming_declaration, the (old) name must denote a library_item. Check that a generic renaming of a child of a parent generic package is not allowed outside the declarative region of the parent generic. Check for subsequent renaming declarations of public children. BA11012 Check that in a library_unit_renaming_declaration, the (old) name must denote a library_item. Check that a generic renaming of a child of a parent generic package is not allowed outside the declarative region of the parent generic. Check that a library unit must be a private descendent of the parent of a private child when the private child has been renamed and the name denoting the renaming has been used in a with clause. Check for subsequent renaming declarations of private children. BA12001 Check that the with-clause of a public child of some library unit cannot include a private child of the same ancestor. BA12002 Check that the with-clause of a public second level descendant of some library unit cannot include a private descendant of the same ancestor. BA12003 Check that the with-clause of the public descendant of a private descendant of a library unit cannot include any private descendants of its (immediate) parent. BA12004 Check that a with-clause of a library unit may not include the private child or any descendant of a private child of some other library unit. BA12005 Check that the with-clause in the body of a (public or private) descendant of a library unit cannot include a private child of a different library unit. BA12007 Check that the rename of a child unit (i.e. a library unit with an expanded name) does not make declarations within ancestors of the child visible. Check that a parent unit name (in the defining declaration of a child unit) does not designate a renaming declaration. BA12008 Check that a child unit may not be "with"ed using only its simple name. Check that a child unit may not be "with"ed using any abbreviated version of its full expanded name (e.g., grandparent.child rather than grandparent.parent.child) BA13B01 Check that a separate subprogram declared in a private child unit of a public parent does not have visibility into the private part of the package on which its parent depends or the private part of its parent's public sibling. BA13B02 Check that a separate subprogram declared in a public child unit of a private parent does not have visibility into the private part of the package on which its parent depends or the private part of its parent's public sibling. BA15001 Check that configuration pragmas must appear before the first compilation unit of a compilation. BA15002 Check the requirements on a program unit pragma imposed by 10.1.5(4) and the modified 10.1.5(5) from Technical Corrigendum 1. (Originally discussed as AI95-00136.) Specifically: If a program unit pragma is given as a compilation_unit, check that it must have a name and immediately follows the unit. If a program unit pragma is given inside of a package to apply to that package, check that it must appear at the beginning of the package specification, and never in the private part. For a generic package, it must not appear in the generic formal part. Also check that the name given in such a program unit pragma must denote the immediately enclosing program unit. BA21001 Check that each of the following constructs is illegal within a library package declaration to which a pragma Preelaborate applies: (a) A call to a nonstatic function. (b) A primary that is a name of an object, including within the default expression for a default-initialized component, if the name is not a static expression and does not statically denote a discriminant of an enclosing type. (c) A declaration of an object of a descendant of a task type. (d) A declaration of an object of a descendant of a controlled type without an initialization expression. (e) A declaration of an object with a component of a descendant of a private type (outside the scope of the full view) without an initialization expression. (f) An extension aggregate with an ancestor subtype mark denoting a subtype of a controlled type. Check that each of the following constructs is legal within a library package declaration to which a pragma Preelaborate applies: (g) A call to a static function. (h) A primary that is a name of an ob BA21002 Check that each of the following constructs is illegal within the body of a library package to which a pragma Pure applies: (a) A statement other than a null statement. (b) A primary that is a name of an object, if the name is not a static expression and does not statically denote a discriminant of an enclosing type. (c) A declaration of an object of a descendant of a protected type with entry declarations. (d) A declaration of a variable, with or without an initialization expression, outside of a subprogram, generic subprogram, task unit, or protected unit. (e) A declaration of a named access type outside of a subprogram, generic subprogram, task unit, or protected unit. (f) An extension aggregate with an ancestor subtype mark denoting a subtype of a private extension. (g) A declaration of a (constant) object which causes the evaluation of a default expression that will call a user-defined function. Check that each of the following constructs is legal within the body of a library package to which a prag BA21003 Check that all compilation units of a preelaborated library unit must depend semantically only on compilation units of other preelaborated library units. Check that all compilation units of a declared-pure library unit must depend semantically only on compilation units of other library units which are declared pure. Check that a preelaborated unit may have a non-preelaborable child unit, but not a non-preelaborable subunit. BA21004 Check the requirements of the modified RM-10.2.1(11) from Technical Corrigendum 1 (originally discussed as AI95-00002). This change does not negate the requirement of RM-10.2.1(11), which requires that all semantic dependents of a preelaborated library unit also be preelaborated (whether or not they are used during elaboration). BA21A01 Check that an instantiation of a generic library package declaration to which a pragma Preelaborate applies is illegal if the instantiation occurs within a library package declaration to which a pragma Preelaborate also applies, and the generic library package contains any of the following constructs in its visible or private part (such that the construct is evaluated upon instantiation): (a) A call to a nonstatic function. (b) A call to a formal function, if the corresponding actual is a nonstatic function. (c) A primary that is a name of an object, if the name is not a static expression and does not statically denote a discriminant of an enclosing type. (d) A declaration of an object of a descendant of a protected type with entry declarations. (e) A declaration of an object of a descendant of a controlled type without an initialization expression. (f) A declaration of an object of a descendant of a private type (outside the scope of the full view) without an initialization expression. (g) A declaration of BA21A02 Check that the body corresponding to a generic library package declaration to which a pragma Preelaborate applies is illegal if it contains any of the following constructs (if the construct would be elaborated upon instantiation): (a) A statement other than a null statement. (b) A call to a nonstatic function. (c) A call to a formal function. (d) A primary that is a name of an object, including within the default expression for a default-initialized component, if the name is not a static expression and does not statically denote a discriminant of an enclosing type. (e) A declaration of an object of a descendant of a task type. (f) A declaration of an object with a component of a descendant of a controlled type without an initialization expression. (g) A declaration of an object with a component of a descendant of a private type (outside the scope of the full view) without an initialization expression. (h) A declaration of an object of a descendant of a private extension (outside the scope of the full view) BB10001 Check that separate exception handlers for Constraint_Error and Numeric_Error are not allowed within a handled sequence of statements. BB20001 Check that an exception_name of a choice cannot denote an exception declared in a generic formal package. BC30001 Check that, in the visible part of an instance, legality rules are enforced at compile time of the generic instantiation, and not enforced in other parts of the instance. Specifically, check that, for a tagged actual type passed to a non-tagged formal private type, a tagged type may not be derived from the actual in the visible part of an instance, but may be derived in the private part or body. Check that a non-tagged type derived from a tagged parent type in the private part of an instance is not treated as tagged outside the instance. BC40001 Check that the type of a generic formal object of mode in must not be limited. BC40002 Check that, for a generic formal object of mode in: If the formal object is of tagged type T, the type of the actual must be T. If the formal object is of type T'Class, the type of the actual must be a type in that class. Check that, for a generic formal object of mode in out: If the formal object is of tagged type T, the type of the actual must be T. If the formal object is of type T'Class, the type of the actual must be T'Class. BC50001 Check that, for a generic formal derived type, the actual must be in the class rooted at the ancestor subtype. Check for scalar, array, and access types. BC50002 Check that, for a generic formal derived type, the actual must be in the class rooted at the ancestor subtype. Check for record and tagged types. BC50003 Check that the actual corresponding to a formal signed integer type may not be a modular type. Check that the actual corresponding to a formal modular type may not be a signed integer type. BC50004 Check that the actual corresponding to a formal ordinary fixed point type may not be a decimal fixed point type. Check that the actual corresponding to a formal decimal fixed point type may not be a ordinary fixed point type. BC51002 Check that if a generic formal derived subtype is definite, the actual subtype must not be indefinite. Check in cases where the formal subtype appears in contexts where an indefinite subtype would be legal. BC51003 Check that, for a generic formal derived type with no discriminant part, if the ancestor subtype is constrained, the actual subtype must be constrained and must be statically compatible with the ancestor. Check for the case where both constraints are static and the actual subtype is defined by a subtype declaration. BC51004 Check that, for a generic formal derived type with no discriminant part, if the ancestor subtype is constrained, the actual subtype must be constrained and must be statically compatible with the ancestor. Check for the case where both constraints are static and the actual subtype is defined by a derived type declaration. BC51005 Check that, for a generic formal derived type with no discriminant part, if the ancestor subtype is an unconstrained access or record subtype, the actual subtype must be unconstrained. BC51006 Check that, for a generic formal derived type with no discriminant part, if the ancestor subtype is an unconstrained array or tagged subtype, the actual subtype must be unconstrained. BC51007 Check that, for a generic formal derived type with no discriminant part, if the ancestor subtype is an unconstrained discriminated subtype, the actual type must have the same number of discriminants, and each discriminant of the actual must correspond to a discriminant of the ancestor. BC51011 Check that, for a formal private type with a known discriminant part, the subtype of each discriminant of the actual type must statically match the subtype of the corresponding discriminant of the formal type. BC51012 Check that, if the reserved word "abstract" does not appear in the declaration of a formal derived type, the actual type must not be an abstract type. Check that, if the ancestor type is abstract, and the formal derived type is not, neither the ancestor type nor its abstract descendants may be passed as actuals. Check that, if the formal derived type is abstract, then the following entities that are of the formal type are illegal: a component, an object created by an object declaration or an allocator, a generic formal object of mode in, the the result type of a non-abstract function. BC51013 Check that, if the reserved word "abstract" does not appear in the declaration of a formal private type, the actual type must not be an abstract type. Check that, if the formal private type is abstract, then the following entities that are of the formal type are illegal: a component, an object created by an object declaration or an allocator, a generic formal object of mode in, the result type of a non-abstract function. BC51015 Check that if the actual type corresponding to a non-tagged formal private type is tagged, an instance is illegal if a (non-tagged) derived type is declared in the visible part. Check that an instance is legal if the derived type is declared in the private part or in the body. BC51016 Check that, if the reserved word "abstract" appears in the declaration of a formal private type, the reserved word "tagged" must also appear. Check that, if the reserved word "abstract" appears in the declaration of a formal derived type, the reserved words "with private" must also appear. Check that a tagged type derived from a non-tagged generic formal private or derived type is illegal. BC51017 Check that alternative orderings of reserved words in a formal private type declaration are illegal. BC51018 Check that alternative orderings of reserved words in a formal (tagged) derived type declaration are illegal. BC51019 Check that a generic formal derived tagged type is a private extension. Specifically, check that, for a generic formal derived type whose ancestor type has a primitive subprogram which is a function with a controlling result, the function must be overridden for non-abstract record extensions of the formal derived type. Check that the function need not be overridden for record extensions, nor for private extensions, although for non-abstract private extensions it must be overridden for the corresponding full type. BC51020 Check that, for an abstract generic formal derived type whose ancestor type has an abstract primitive subprogram, non-abstract record and private extensions of the formal derived type must override the subprogram. Check that abstract record and private extensions need not override the subprogram. Check that, for a non-abstract generic formal derived type whose ancestor type has an abstract primitive subprogram, record and private extensions of the formal derived type need not override the subprogram. BC51B01 Check that if a generic formal private subtype is definite, the actual subtype must not be indefinite, even if the formal subtype appears only in contexts where an indefinite subtype would be legal. BC51B02 Check that the ancestor of a formal derived type may not be class- wide. Check that a formal derived type may not have a known discriminant part. Check that if a generic formal private or derived subtype is indefinite, it must not appear in a context which requires a definite subtype. BC51C01 Check that the actual type passed to an abstract generic formal derived type may be either abstract or non-abstract, as may record and private extensions of the formal type. Check that, for a non-abstract type derived from an abstract formal derived type, all abstract primitive subprograms inherited from the actual type must be overridden in the instance. BC51C02 Check that the actual type passed to an abstract generic formal private type may be either abstract or non-abstract, as may record and private extensions of the formal type. Check that, for a non-abstract type derived from an abstract formal private type, all abstract primitive subprograms inherited from the actual type must be overridden in the instance. BC53001 Check that the index subtypes of an unconstrained formal array subtype and its corresponding actual subtype must statically match. Check that the index ranges of a constrained formal array subtype and its corresponding actual subtype must statically match. Check that the component subtypes of a formal array type and its corresponding actual type must statically match. BC53002 Check that if a formal array type has aliased components, the corresponding actual type must also have aliased components. Check that if a formal array type does not have aliased components, the corresponding actual type may nevertheless have aliased components. BC54001 Check that if a generic formal access type contains the general access modifier "constant," the actual must be an access-to-constant type. Check that if a generic formal access type contains the general access modifier "all," the actual must be a general access-to-variable type. Check that if a generic formal access type contains no general access modifiers and is not a formal access-to-subprogram type, the actual must be a general or pool-specific access-to-variable type. Check that if a generic formal access type is a formal access-to-subprogram type, the actual must be an access-to-subprogram type. BC54002 Check that, for a formal access-to-subprogram subtype, the designated profiles of the formal and actual must be mode-conformant. Check that if the calling convention of the formal is not protected, the calling convention of the actual must not be protected. BC54003 Check that, for a formal access-to-subprogram subtype, the corresponding parameter and result types of the designated profiles of the formal and actual must be the same. Specifically, check for the case where the parameters in the profile of the formal type are themselves formal types. BC54A01 Check that, for a formal access-to-subprogram subtype whose profile contains access parameters, the designated subtypes of the corresponding access parameters in the formal and actual profiles must statically match. Check cases where the designated subtype is an elementary subtype. BC54A02 Check that, for a formal access-to-subprogram subtype whose profile contains access parameters, the designated subtypes of the corresponding access parameters in the formal and actual profiles must statically match. Check cases where the designated subtype is a composite subtype. BC54A03 Check that, for a formal access-to-subprogram subtype whose profile contains access parameters, the designated subtypes of the corresponding access parameters in the formal and actual profiles must statically match. Check cases where the designated subtype is a generic formal subtype. BC54A04 Check that, for a formal access-to-object type, the designated subtypes of the formal and actual must statically match. Check for the case where the access-to-object type is a general access-to-constant type. BC54A05 Check that, for a formal access-to-object type, the designated subtypes of the formal and actual must statically match. Check for the case where the access-to-object type is a general access-to-variable type. BC54A06 Check that, for a formal access-to-object type, the designated subtypes of the formal and actual must statically match. Check for the case where the access-to-object type is a pool-specific access-to-variable type. BC70001 Check that the actual corresponding to a generic formal package must be an instance of the template for the formal package. Check for the case where the formal package is declared in a library- level generic package. BC70002 Check that the actual corresponding to a generic formal package must be an instance of the template for the formal package. Check for the case where the formal package is declared in a library- level generic subprogram. BC70003 Check that the template in a formal package declaration must be a generic package. Check for the case where the formal package is declared in a library-level generic package. BC70004 Check that the template in a formal package declaration must be a generic package. Check for the case where the formal package is declared in a library-level generic subprogram. BC70005 Check that if a formal package actual part is not (<>), the generic formal part of the template is not part of the visible part of the formal package. Check for the case where the formal package is declared in a library-level generic package. BC70006 Check that if a formal package actual part is not (<>), the generic formal part of the template is not part of the visible part of the formal package. Check for the case where the formal package is declared in a library-level generic subprogram. BC70007 Check that an actual instance of a generic formal package is rejected if its actuals do not match the corresponding actuals in the formal package actual part. Specifically, check that the following cases are illegal: For a formal object of mode IN: The actuals are both static expressions but do not have the same value. The actuals are not both static expressions and do not statically denote the same constant. The actuals are not both the literal null. BC70008 Check that the actual corresponding to a generic formal package must be an instance of the template for the formal package. Check for the case where the formal package is declared in a library- level generic subprogram. Check for the case where the actuals have been renamed. Check that a generic renaming declaration which renames the template may be used in instantiations of the template. BC70009 Check that an actual instance of a generic formal package is rejected if its actuals do not match the corresponding actuals in the formal package actual part. Specifically, check that, for formal subprograms and packages, the actuals must statically denote the same entity. BC70010 Check that an actual instance of a generic formal package is rejected if its actuals do not match the corresponding actuals in the formal package actual part. Specifically, check that, for formal subtypes, the actuals must denote statically matching subtypes. BDB0A01 Check that Storage_Size may not be specified for a derived access_to_object type. Check that Storage_Pool may not be specified for a derived access_to_object type. Check that type Root_Storage_Pool is abstract, and requires overriding definitions for procedures Allocate, Deallocate and function Storage_Size. Check that Storage_Size may not be specified for a given access type if Storage_Pool is specified for it. BDD2001 Check that Stream_IO attributes 'Input, 'Output, 'Class'Input, and 'Class'Output cannot be used with limited types, including composite types containing limited components. BDD2002 Check that a limited type extension is illegal if (1) the parent type has user-defined Read or Write attributes and (2) the extension has a limited component which does not have a user-defined Read or Write attribute. (Defect Report 8652/0040, Technical Corrigendum 1, last sentence of 13.13.2(9/1)). BDE0001 Check that the explicit declaration of a primitive subprogram of a tagged type must occur before the type is frozen. Check for cases where the tagged type is frozen by: The declaration of a record extension (check also that a private extension does not freeze the parent type, and that freezing is deferred until the full type declaration). The declaration of an object of the type. An expression that is an allocator, the type of which designates the tagged type. Check that the tagged type is not frozen by a nonstatic expression that is part of a default expression. BDE0002 Check that the explicit declaration of a primitive subprogram of a tagged type must occur before the type is frozen. Check for cases where the component type of a composite type is a tagged type, and the tagged type is frozen by: The declaration of an object of the composite type. An expression that is an allocator, the type of which designates the composite type. An expression that is an aggregate, which contains a composite value of the composite type. Check that the tagged type is not frozen by a nonstatic expression that is part of a default expression. BDE0003 Check that the explicit declaration of a primitive subprogram of a tagged type must occur before the type is frozen. Check for cases where the tagged type is frozen by the completion of a deferred constant declaration. Check also that the deferred constant declaration itself does not freeze the type. Check that a deferred constant is completed before the constant is frozen. BDE0004 Check that the explicit declaration of a primitive subprogram of a tagged type must occur before the type is frozen. Check for cases where the tagged type is frozen by the occurrence of a generic instantiation. Check that the tagged type is not frozen by a nonstatic expression that is a default name. BDE0005 Check that the explicit declaration of a primitive subprogram of a tagged type must occur before the type is frozen. Check for cases where the primitive subprogram occurs in a package body. BDE0006 Check that a representation clause for a type must occur before the type is frozen. Check for cases where the type is frozen by: The declaration of an object of the type. The declaration of an object with a component of the type. The declaration of a record extension of the type. An expression that is an allocator, the type of which designates the type. BDE0007 Check that a representation clause for an object or a type must occur before the object or type is frozen. Check for cases where the object or type is frozen by the occurrence of a generic instantiation. Check that an instance body does not cause freezing of entities declared before it within the same declarative part. BDE0008 Check that a representation clause for a type must occur before the type is frozen. Check for cases where the type is frozen by a static expression or a nonstatic expression which is not a default expression. Check that a nonstatic expression that is part of a default expression does not cause freezing. Check for cases of subprogram renaming. BXA8001 Check that Append_File mode has not been added to package Direct_IO. APPLICABILITY CRITERIA: Applicable to all implementations that support Direct_IO operations. BXAC001 Check that a stream is limited and may not be the target of an assignment. BXAC002 Check that the Set_Position procedure and Position function are not predefined in Stream_IO. Check that the type File_Offset is not predefined in Stream_IO. Check that the Set_Index procedure and Index function are predefined in Stream_IO. Check that the type Positive_Count is predefined in Stream_IO. Check that the appropriate parameter types are required for the Stream_IO procedure Set_Index. BXAC003 Check that an attempt to use the 'Write or 'Read type attribute values to write or read a Stream_IO file is rejected when a stream file object is provided as the parameter, rather than an stream access value. Check that the correct type 'Write or 'Read attribute value is required when writing or reading data to/from a stream. Check that an attempt to use the 'Write or 'Read type attribute values as attributes of an object rather than a type are rejected by the compiler. BXAC004 Check that an attribute reference for the Stream_IO attributes 'Write and 'Read is illegal if the type is limited, including task types and composite types containing limited components. BXAC005 Check that Text_IO.File_Type objects cannot be used in conjunction with stream-oriented attributes 'Write and 'Read. Check that Streams.Stream_IO.File_Type objects cannot be used in Text_IO file data transfer operations. Check that stream access objects cannot be used as file object parameters of Text_IO.Put and Text_IO.Get procedures. Check that Put and Get are not defined as type attributes for use with stream files. Check that the package Stream_Support, which was originally defined in the 9X Mapping Specification and Ada 9X ILS, but which has been changed to package Streams in AARM;3.0, is not included in the compilation system predefined library. (Note: This portion of the objective can be deleted in the future.) BXC3001 Check that pragmas Interrupt_Handler and Attach_Handler are recognized. Check that the handler is a parameterless protected procedure; check that the pragmas are allowed only immediately in a protected definition. Check that Attach_Handler will accept an expression only of type Interrupts.Interrupt_ID. BXC3002 Check that pragmas Interrupt_Handler and Attach_Handler are recognized for protected types. Check that the pragmas are allowed only immediately in a protected definition. Check that a protected declaration for Attach_Handler must be library level. Check that a protected type declaration for Interrupt_Handler must be library level and that any object declaration of that type must be library level. BXC5001 Check that pragma Discard_Names may only be declared immediately within a declarative part, immediately within a package specification or as a configuration pragma. Check that its parameter, if present, may denote only a non-derived enumeration subtype, tagged subtype or an exception. BXC6001 Check that the name referenced in pragmas Atomic and Volatile may only be an object, a non-inherited component or a full type. Check that the name referenced in Atomic_Components or Volatile_Components must be an array type or an object of an anonymous array type. BXC6002 Check that if an atomic object is used as an actual for a generic formal object of mode in out, the type of the generic formal object must be atomic. Check that if the prefix of 'Access denotes an atomic object (including a component), the designated type of the resulting access type must be atomic. BXC6003 Check that the implementation rejects a pragma Atomic when it cannot support indivisible reads or updates of the object. Check that the implementation rejects a pragma Atomic_Components when it cannot support indivisible reads or updates of the components of the array object. BXC6A01 Check that if a volatile object is passed as a parameter, then the type of the formal parameter must not be a non-volatile by-reference type. BXC6A02 Check that if a volatile object is used as an actual for a generic formal object of mode in out, the type of the generic formal object must be volatile. Check that if the prefix of 'Access denotes a volatile object (including a component), the designated type of the resulting access type must be volatile. BXC6A03 Check that if a volatile type is used as an actual for a generic formal derived type, the ancestor of the formal type must not be a non-volatile by-reference type. BXC6A04 Check that if a pragma Volatile, Volatile_Components, Atomic, or Atomic_Components applies to a stand-alone constant object, then a pragma Import must also apply to it. Check that if a stand-alone constant object is atomic or volatile solely because of its type, a pragma Import need not apply to it. BXD1001 Check that a Priority pragma is allowed immediately within a task_definition, a protected_definition, and the declarative_part of a subprogram_body. Check that a Priority pragma is not allowed in other places. Check that an Interrupt_Priority pragma is allowed immediately within a task_definition or a protected_definition. Check that an Interrupt_Priority pragma is not allowed in the declarative part of a subprogram_body. Check that only one such pragma is allowed within a given construct. BXD1002 Check that the pragma priority expression must be static when the pragma is located within the declarative_part of a subprogram_body. Check that the expression in a Priority and Interrupt_Priority pragma is required to be of type Integer. Check that the pragma priority expression need not be static when the pragma is located within a task_definition or protected_definition. BXE2007 Check that a declared Shared_Passive library unit may not contain: objects that are not preelaborable, library level task object declarations, protected objects with entries, access types that designate a class-wide type, access types that designate a task type, or access types that designate a protected type with entries. Check that a declared Shared_Passive library unit may contain: objects that are preelaborable, protected objects without entries, protected types with entries, and task types. BXE2008 Check that a declared Remote_Types library unit may not contain: variable declarations; private types where the full view of the type contains a non-remote access type and no READ and WRITE attributes are supplied; visible access types where the type is neither an access-to-subprogram type nor a general access type that designates a class-wide limited private type. Check that a declared Remote_Types library unit may contain: private types where the full view of the type contains a non-remote access type and READ and WRITE attributes are supplied. BXE2009 Check that a declared Remote_Call_Interface library unit may not contain: variable declarations, task type declarations, protected type declarations, nested generic declarations, limited types, subprogram declarations to which a pragma inline applies, non-preelaborable constant declarations, a subprogram declaration with a formal parameter of an access type, or a subprogram declaration with a formal parameter of a limited type without READ and WRITE attributes. Check that a Remote_Call_Interface library unit may not depend upon a shared passive or normal package. Check that a declared Remote_Call_Interface library unit may contain: subprogram declaration with a formal parameter of a limited type with READ and WRITE attributes. Check that pragma Asynchronous can only be applied to RCI procedures containing only mode in parameters. BXE2010 Check that a public child library unit of a remote call interface library unit must itself have a Remote_Call_Interface pragma. Check that a private child library unit of a remote call interface library unit are not subjected to the restrictions of an RCI unit unless the private child unit contains a Remote_Call_Interface pragma. Check the parameterized form of the pragma to see that a library unit name can be specified and if it is specified, it must correspond to the library unit in which it is contained. Check that a public child library unit of a normal package cannot be a remote call interface unit. Check that a public child library unit of a pure package can be a remote call interface unit. BXE2011 Check that a value of a remote access-to-subprogram type can only be converted to another conformant remote access-to-subprogram type. Check that the prefix of an access attribute_reference that yields a value of a remote access-to-subprogram type shall statically denote a conformant remote subprogram. Check that a value of a remote access-to-class-wide type can only be converted to another remote access-to-class-wide type. Check that the Storage_Pool and Storage_Size attributes are not defined for remote access-to-class-wide types. BXE2012 Check that a remote access-to-class-wide type must designate a limited private type. Check that the primitive subprograms of the limited private type designated by a remote access-to-class-wide type can only have access parameters for the controlling parameters. Check that non-controlling parameters of limited private types designated by a remote access-to-class-wide type are required to have Read and Write attributes. Check that a value of a remote access-to-class-wide type can be implicitly converted only as part of a dispatching call where the value designates a controlling operand of the call. BXE2013 Check the requirements of the revised E.2(4) from Technical Corrigendum 1 (originally discussed as AI95-00048). A shared passive or remote types library unit must be a package or generic package, not a subprogram or generic subprogram. BXE2A01 Check that a Declared Pure library unit can depend only on other Declared Pure library units. Specifically, it can not depend on a Shared Passive Unit. BXE2A02 Check that a Declared Pure library unit can depend only on other Declared Pure library units. Specifically it can not depend on a Remote Types unit. BXE2A03 Check that a Declared Pure library unit can depend only on other Declared Pure library units. Specifically it cannot depend on an Normal unrestricted unit. BXE2A04 Check that a Shared Passive library unit can depend only on other Shared Passive or Declared Pure library units. Specifically that it can not depend on a Remote Types library unit. BXE2A05 Check that a Shared Passive library unit can depend only on other Shared Passive library units or Declared Pure library units. Specifically that it can not depend on a Normal unrestricted unit. BXE2A06 Check that a Remote Types library unit can depend only on other Remote Types library units, Declared Pure library units or Shared Passive library units. Specifically that it cannot depend on a Normal unrestricted unit BXE4001 Check that pragma Asynchronous can only be applied to one of the following three categories of items: Remote procedures where the formal parameters of the procedures are all of mode in; The first subtype of a remote access-to-procedure type where the formal parameters of the designated profile of the type are all of mode in; Remote access-to-class-wide types. BXF1001 Check that values of 2 and 10 are allowable values for Machine_Radix of a decimal first subtype. Check that values other than 2 and 10 are not allowed for Machine_Radix of a decimal first subtype. Check that the expression used to define Machine_Radix must be static. Check that the package Ada.Decimal is available. Check that 10**(-Max_Scale) is allowed as a decimal type's delta. Check that 10**(-Min_Scale) is allowed as a decimal type's delta. Check that Min_Delta and Max_Delta are allowed for delta in decimal fixed point definitions. Check that Max_Decimal_Digits is allowed for digits in a decimal fixed point definition. Check that a value N larger than Max_Scale is not allowed in the expression 10**(-N) as a decimal type's delta. Check that a value N smaller than Min_Scale is not allowed in the expression 10**(-N) as a decimal type's delta. Check that neither a value smaller than Min_Delta nor a value larger than Max_Delta are allowed for delta in decimal fixed point definitions. Check that BXH4001 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Protected_Types disallows protected types in the compilations. BXH4002 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Allocators disallows allocators in the compilations. BXH4003 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Local_Allocators disallows allocators and generic package instantiations in subprograms, generic subprograms, tasks, and entry bodies. Check that allocators and generic instantiations are still allowed at the library package level. BXH4004 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Unchecked_Deallocation disallows the use of Unchecked_Deallocation; Check that the application of the configuration pragma Restrictions with the specific restriction: Immediate_Reclamation is accepted. BXH4005 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Exceptions is accepted. BXH4006 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Floating_Point is accepted. BXH4007 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Fixed_Point is accepted. BXH4008 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Unchecked_Conversion does not allow the use of Unchecked_Conversion. BXH4009 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Access_Subprograms is accepted. BXH4010 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Unchecked_Access is accepted. BXH4011 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Dispatch disallows occurrences of T'Class. BXH4012 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_IO rejects any semantic dependence on Sequential_IO, Direct_IO, Text_IO, Wide_Text_IO or Stream_IO. BXH4013 Check pragma Restrictions. Check that the application of the configuration pragma Restrictions with the specific restriction: No_Delay is accepted. C250001 Check that wide character literals are supported. Check that wide character string literals are supported. C250002 Check that characters in Latin-1 above ASCII.Del can be used in identifiers, character literals and strings. C330001 Check that a variable object of an indefinite type is properly initialized/constrained by an initial value assignment that is a) an aggregate, b) a function, or c) an object. Check that objects of the above types do not need explicit constraints if they have initial values. C330002 Check that if a subtype indication of a variable object defines an indefinite subtype, then there is an initialization expression. Check that the object remains so constrained throughout its lifetime. Check for cases of tagged record, arrays and generic formal type. C332001 Check that the static expression given for a number declaration may be of any numeric type. Check that the type of a named number is universal_integer or universal_real regardless of the type of the static expression that provides its value. C340001 Check that user-defined equality operators are inherited by a derived type except when the derived type is a nonlimited record extension. In the latter case, ensure that the primitive equality operation of the record extension compares any extended components according to the predefined equality operators of the component types. Also check that the parent portion of the extended type is compared using the user-defined equality operation of the parent type. C340A01 Check that a tagged type declared in a package specification may be passed as a generic formal (tagged) private type to a generic package declaration. Check that the formal type may be extended with a record extension in the generic package. Check that, in the instance, the record extension inherits the user-defined primitive subprograms of the tagged actual. C340A02 Check that a record extension (declared in a package specification) of a tagged type (declared in a different package specification) may be passed as a generic formal (tagged) private type to a generic package declaration. Check that the formal type may be further extended with a record extension in the generic package. Check that, in the instance, the record extension inherits the user-defined primitive subprograms of the tagged actual, including those inherited by the actual from its parent. C341A01 Check that formal parameters of a class-wide type can be passed values of any specific type within the class. C341A02 Check that class-wide objects can be reassigned with objects from the same specific type used to initialize them. C341A03 Check that an object of one class-wide type can initialize a class-wide object of a different type when the operation is embedded in a generic unit. C341A04 Check that class-wide objects can be initialized using allocation. C352001 Check that the predefined Character type comprises 256 positions. Check that the names of the non-graphic characters are usable with the attributes (Wide_)Image and (Wide_)Value, and that these attributes produce the correct result. C354002 Check that the attributes of modular types yield correct values/results. The attributes checked are: First, Last, Range, Base, Min, Max, Succ, Pred, Image, Width, Value, Pos, and Val C354003 Check that the Wide_String attributes of modular types yield correct values/results. The attributes checked are: Wide_Image Wide_Value C360002 Check that modular types may be used as array indices. Check that if aliased appears in the component_definition of an array_type that each component of the array is aliased. Check that references to aliased array objects produce correct results, and that out-of-bounds indexing correctly produces Constraint_Error. C371001 Check that if a discriminant constraint depends on a discriminant, the evaluation of the expressions in the constraint is deferred until an object of the subtype is created. Check for cases of records with private type component. C371002 Check that if a discriminant constraint depends on a discriminant, the evaluation of the expressions in the constraint is deferred until an object of the subtype is created. Check for cases of records. C371003 Check that if a discriminant constraint depends on a discriminant, the evaluation of the expressions in the constraint is deferred until an object of the subtype is created. Check for cases of records where the component containing the constraint is present in the subtype. C390001 Check that a record extension can be declared in the same package as its parent, and that this parent may be a tagged record or a record extension. Check that each derivative inherits all user- defined primitive subprograms of its parent (including those that its parent inherited), and that it may declare its own primitive subprograms. Check that predefined equality operators are defined for the root tagged type. Check that type conversion is defined from a type extension to its parent, and that this parent itself may be a type extension. C390002 Check that a tagged base type may be declared, and derived from in simple, private and extended forms. (Overlaps with C390B04) Check that the package Ada.Tags is present and correctly implemented. Check for the correct operation of Expanded_Name, External_Tag and Internal_Tag within that package. Check that the exception Tag_Error is correctly raised on calling Internal_Tag with bad input. C390003 Check that for a subtype S of a tagged type T, S'Class denotes a class-wide subtype. Check that T'Tag denotes the tag of the type T, and that, for a class-wide tagged type X, X'Tag denotes the tag of X. Check that the tags of stand alone objects, record and array components, aggregates, and formal parameters identify their type. Check that the tag of a value of a formal parameter is that of the actual parameter, even if the actual is passed by a view conversion. C390004 Check that the tags of allocated objects correctly identify the type of the allocated object. Check that the tag corresponds correctly to the value resulting from both normal and view conversion. Check that the tags of accessed values designating aliased objects correctly identify the type of the object. Check that the tag of a function result correctly evaluates. Check this for class-wide functions. The tag of a class-wide function result should be the tag appropriate to the actual value returned, not the tag of the ancestor type. C390005 Check that a private tagged type declared in a package specification may be extended with a private extension in a different package specification, and that this private extension may in turn be extended by a private extension in a third package. Check that each derivative inherits the user-defined primitive subprograms of its parent (including those that its parent inherited), that it may override these inherited primitive subprograms, and that it may also declare its own primitive subprograms. Check that type conversion is defined from a type extension to its parent, and that this parent itself may be a type extension. C390006 Check that a private tagged type declared in a package specification may be extended with a private extension in a different package specification, and that this private extension may in turn be extended by a record extension in a third package. Check that each derivative inherits the user-defined primitive subprograms of its parent (including those that its parent inherited), that it may override these inherited primitive subprograms, and that it may also declare its own primitive subprograms. Check that type conversion is defined from a type extension to its parent, and that this parent itself may be a type extension. C390007 Check that the tag of an object of a tagged type is preserved by type conversion and parameter passing. C390010 Check that if S is a subtype of a tagged type T, and if S is constrained, then the allowable values of S'Class are only those that, when converted to T, belong to S. C390011 Check that tagged types declared within generic package declarations generate distinct tags for each instance of the generic. C390A01 Check that a nonprivate tagged type declared in a package specification may be extended with a record extension in a different package specification, and that this record extension may in turn be extended by a record extension. Check that each derivative inherits the user-defined primitive subprograms of its parent (including those that its parent inherited), that it may override these inherited primitive subprograms, and that it may also declare its own primitive subprograms. Check that predefined equality operators are defined for the tagged type and its derivatives. Check that type conversion is defined from a type extension to its parent, and that this parent itself may be a type extension. C390A02 Check that a nonprivate tagged type declared in a package specification may be extended with a record extension in a different package specification, and that this record extension may in turn be extended by a private extension in a third package. Check that each derivative inherits the user-defined primitive subprograms of its parent (including those that its parent inherited), that it may override these inherited primitive subprograms, and that it may also declare its own primitive subprograms. Check that predefined equality operators are defined for the tagged type and its derivatives. Check that type conversion is defined from a type extension to its parent, and that this parent itself may be a type extension. C390A03 Check that a nonprivate tagged type declared in a package specification may be extended with a private extension in a different package specification, and that this private extension may in turn be extended by a private extension. Check that each derivative inherits the user-defined primitive subprograms of its parent (including those that its parent inherited), that it may override these inherited primitive subprograms, and that it may also declare its own primitive subprograms. Check that predefined equality operators are defined for the tagged type and its derivatives. Check that type conversion is defined from a type extension to its parent, and that this parent itself may be a type extension. C391001 Check that structures nesting discriminated records as components in record extension are correctly supported. Check for this using limited private structures. Check that record extensions inherit all the visible components of their ancestor types. Check that discriminants are correctly inherited. C391002 Check that structures nesting discriminated records as components in record extension are correctly supported. Check that record extensions inherit all the visible components of their ancestor types. Check that discriminants are correctly inherited. C392002 Check that the use of a class-wide formal parameter allows for the proper dispatching of objects to the appropriate implementation of a primitive operation. Check this in the case where the root tagged type is defined in a generic package, and the type derived from it is defined in that same generic package. C392003 Check that the use of a class-wide formal parameter allows for the proper dispatching of objects to the appropriate implementation of a primitive operation. Check this where the root tagged type is defined in a package, and the extended type is defined in a nested package. C392004 Check that subprograms inherited from tagged derivations, which are subsequently redefined for the derived type, are available to the package defining the new class via view conversion. Check that operations performed on objects using view conversion do not affect the extended fields. Check that visible operations not masked by the deriving package remain available to the client, and do not affect the extended fields. C392005 Check that, for an implicitly declared dispatching operation that is overridden, the body executed is the body for the overriding subprogram, even if the overriding occurs in a private part. Check for the case where the overriding operations are declared in a public child unit of the package declaring the parent type, and the descendant type is a private extension. Check for both dispatching and nondispatching calls. C392008 Check that the use of a class-wide formal parameter allows for the proper dispatching of objects to the appropriate implementation of a primitive operation. Check this for the case where the root tagged type is defined in a package and the extended type is defined in a dependent package. C392010 Check that a subprogram dispatches correctly with a controlling access parameter. Check that a subprogram dispatches correctly when it has access parameters that are not controlling. Check with and without default expressions. C392011 Check that if a function call with a controlling result is itself a controlling operand of an enclosing call on a dispatching operation, then its controlling tag value is determined by the controlling tag value of the enclosing call. C392012 (This test has been removed.) Check that if all of the controlling operands of a call on a dispatching operation are tag indeterminate, then if the call has a controlling result and is a controlling operand of an enclosing call, then its controlling tag value is determined by the controlling tag value of the enclosing call. C392013 Check that the "/=" implicitly declared with the declaration of "=" for a tagged type is legal and can be used in a dispatching call. (Defect Report 8652/0010, as reflected in Technical Corrigendum 1). C392014 Check that objects designated by X'Access (where X is of a class-wide type) and new T'Class'(...) are dynamically tagged and can be used in dispatching calls. (Defect Report 8652/0010). C392A01 Check that the use of a class-wide formal parameter allows for the proper dispatching of objects to the appropriate implementation of a primitive operation. Check this for the root tagged type defined in a package, and the extended type is defined in that same package. C392C05 Check that for a call to a dispatching subprogram the subprogram body which is executed is determined by the controlling tag for the case where the call has statically tagged controlling operands of the type T. Check this for various operands of tagged types: objects (declared or allocated), formal parameters, view conversions, function calls (both primitive and non-primitive). C392C07 Check that for a call to a dispatching subprogram the subprogram body which is executed is determined by the controlling tag for the case where the call has dynamic tagged controlling operands of the type T. Check for calls to these same subprograms where the operands are of specific statically tagged types: objects (declared or allocated), formal parameters, view conversions, and function calls (both primitive and non-primitive). C392D01 Check that, for an implicitly declared dispatching operation that is overridden, the body executed is the body for the overriding subprogram, even if the overriding occurs in a private part. Check that, for an implicitly declared dispatching operation that is NOT overridden, the body executed is the body of the corresponding subprogram of the parent type. Check for the case where the overriding (and non-overriding) operations are declared for a private extension (and its full type) in a public child unit of the package declaring the ancestor type, and the ancestor type is a tagged private type whose full view is itself a derived type. C392D02 Check that a primitive procedure declared in a private part is not overridden by a procedure explicitly declared at a place where the primitive procedure in question is not visible. Check for the case where the non-overriding operation is declared in a separate (non-child) package from that declaring the parent type, and the descendant type is a record extension. C392D03 Check that, for an inherited dispatching operation that is overridden, the body executed is the body of the overriding subprogram, even if the overriding occurs in a private part. Check for the case where the overriding operation is declared in a separate (non-child) package from that declaring the parent type, and the descendant type is a record extension. Check for both dispatching and nondispatching calls. C393001 Check that an abstract type can be declared, and in turn concrete types can be derived from it. Check that the definition of actual subprograms associated with the derived types dispatch correctly. C393007 Check that an extended type can be derived from an abstract type, where the abstract type is defined in a package, and the type derived from it is defined in a distinct library package. C393008 Check that an extended type can be derived from an abstract type. C393009 Check that an extended type can be derived from an abstract type. C393010 Check that an extended type can be derived from an abstract type and that a call on an abstract operation is a dispatching operation. Check that such a call can dispatch to an overriding operation declared in the private part of a package. C393011 Check that an abstract extended type can be derived from an abstract type, and that a a non-abstract type may then be derived from the second abstract type. C393012 Check that a non-abstract subprogram of an abstract type can be called with a controlling operand that is a type conversion to the abstract type. Check that converting to the class-wide type of an abstract type inside an operation of that type causes a "redispatch" of the called operation. C393A02 Check that a dispatching call to an abstract subprogram invokes the correct subprogram body of a descendant type according to the controlling tag. Check that a subprogram can be declared with formal parameters and result that are of an abstract type's associated class-wide type and that such subprograms can be called. 3.4.1(4) C393A03 Check that a non-abstract primitive subprogram of an abstract type can be called as a dispatching operation and that the body of this subprogram can make a dispatching call to an abstract operation of the corresponding abstract type. C393A05 Check that for a nonabstract private extension, any inherited abstract subprograms can be overridden in the private part of the immediately enclosing package and that calls can be made to private dispatching operations. C393A06 Check that a type that inherits abstract operations but overrides each of these operations is not required to be abstract, and that objects of the type and its class-wide type may be declared and passed in calls to the overriding subprograms. C393B12 Check that an extended type can be derived in the specification of a generic package when the parent is an abstract type in a library package. C393B13 Check that an extended type can be derived from an abstract type when that derivation is declared in a child package. C393B14 Check that an extended type can be derived in a private child package from an abstract type defined in a library package. C3A0001 Check that access to subprogram type can be used to select and invoke functions with appropriate arguments dynamically. C3A0002 Check that access to subprogram type can be used to select and invoke procedures with appropriate arguments dynamically. C3A0003 Check that a function in a generic instance can be called using an access-to-subprogram value. C3A0004 Check that access to subprogram may be stored within array objects, and that the access to subprogram can subsequently be called. C3A0005 Check that access to subprogram may be stored within record objects, and that the access to subprogram can subsequently be called. C3A0006 Check that access to subprogram may be stored within data structures, and that the access to subprogram can subsequently be called. C3A0007 Check that a call to a subprogram via an access-to-subprogram value stored in a data structure will correctly dispatch according to the tag of the class-wide parameter passed via that call. C3A0008 Check that subprogram references may be passed as parameters using access-to-subprogram types. Check that the passed subprograms may be invoked from within the called subprogram. C3A0009 Check that subprogram references may be passed as parameters using access-to-subprogram types. Check that the passed subprograms may be invoked from within the called subprogram. C3A0010 Check that an access-to-subprogram type in a generic instance may be used to declare access-to-subprogram objects which invoke subprograms in the instance. C3A0011 Check that an access-to-subprogram object whose type is declared in a parent package, may be used to invoke subprograms in a child package. Check that such access objects may be stored in a data structure and that subprograms may be called by walking the data structure. C3A0012 Check that an access-to-subprogram object can be used to invoke a subprogram when the subprogram body had been declared and implemented as a subunit. C3A0013 Check that a general access type object may reference allocated pool objects as well as aliased objects. (3,4) Check that formal parameters of tagged types are implicitly defined as aliased; check that the 'Access of these formal parameters designates the correct object with the correct tag. (5) Check that the current instance of a limited type is defined as aliased. (5) C3A0014 Check that if the view defined by an object declaration is aliased, and the type of the object has discriminants, then the object is constrained by its initial value even if its nominal subtype is unconstrained. Check that the attribute A'Constrained returns True if A is a formal out or in out parameter, or dereference thereof, and A denotes an aliased view of an object. C3A0015 Check that a derived access type has the same storage pool as its parent. (Defect Report 8652/0012, Technical Corrigendum 3.10(7/1)). C3A1001 Check that the full type completing a type with no discriminant part or an unknown discriminant part may have explicitly declared or inherited discriminants. Check for cases where the types are records and protected types. C3A1002 Check that the full type completing a type with no discriminant part or an unknown discriminant part may have explicitly declared or inherited discriminants. Check for cases where the types are tagged records and task types. C3A2001 Check that an access type may be defined to designate the class-wide type of an abstract type. Check that the access type may then be used subsequently with types derived from the abstract type. Check that dispatching operations dispatch correctly, when called using values designated by objects of the access type. C3A2002 Check that, for X'Access of a general access type A, Program_Error is raised if the accessibility level of X is deeper than that of A. Check for the case where X denotes a view that is a dereference of an access parameter, or a rename thereof. Check for cases where the actual corresponding to X is: (a) An allocator. (b) An expression of a named access type. (c) Obj'Access. C3A2003 Check that, for X'Access of a general access type A, Program_Error is raised if the accessibility level of X is deeper than that of A. Check for the case where X denotes a view that is a dereference of an access parameter, or a rename thereof. Check for the case where X is an access parameter and the corresponding actual is another access parameter. C3A2A01 Check that, for X'Access of a general access type A, Program_Error is raised if the accessibility level of X is deeper than that of A. Check for cases where X'Access occurs in an instance body, and A is passed as an actual during instantiation. C3A2A02 Check that, for X'Access of a general access type A, Program_Error is raised if the accessibility level of X is deeper than that of A. Check for cases where X'Access occurs in an instance body, and A is a type either declared inside the instance, or declared outside the instance but not passed as an actual during instantiation. C410001 Check that evaluating an access to subprogram variable containing the value null causes the exception Constraint_Error. Check that the default value for objects of access to subprogram types is null. C420001 Check that if the index subtype of a string type is a modular subtype whose lower bound is zero, then the evaluation of a null string_literal raises Constraint_Error. This was confirmed by AI95-00138. C431001 Check that a record aggregate can be given for a nonprivate, nonlimited record extension and that the tag of the aggregate values are initialized to the tag of the record extension. C432001 Check that extension aggregates may be used to specify values for types that are record extensions. Check that the type of the ancestor expression may be any nonlimited type that is a record extension, including private types and private extensions. Check that the type for the aggregate is derived from the type of the ancestor expression. C432002 Check that if an extension aggregate specifies a value for a record extension and the ancestor expression has discriminants that are inherited by the record extension, then a check is made that each discriminant has the value specified. Check that if an extension aggregate specifies a value for a record extension and the ancestor expression has discriminants that are not inherited by the record extension, then a check is made that each such discriminant has the value specified for the corresponding discriminant. Check that the corresponding discriminant value may be specified in the record component association list or in the derived type definition for an ancestor. Check the case of ancestors that are several generations removed. Check the case where the value of the discriminant(s) in question is supplied several generations removed. Check the case of multiple discriminants. Check that Constraint_Error is raised if the check fails. C432003 Check that if the type of the ancestor part of an extension aggregate has discriminants that are not inherited by the type of the aggregate, and the ancestor part is a subtype mark that denotes a constrained subtype, Constraint_Error is raised if: 1) any discriminant of the ancestor has a different value than that specified for a corresponding discriminant in the derived type definition for some ancestor of the type of the aggregate, or 2) the value for the discriminant in the record association list is not the value of the corresponding discriminant. Check that the components of the value of the aggregate not given by the record component association list are initialized by default as for an object of the ancestor type. C432004 Check that the type of an extension aggregate may be derived from the type of the ancestor part through multiple record extensions. Check for ancestor parts that are subtype marks. Check that the type of the ancestor part may be abstract. C433001 Check that an others choice is allowed in an array aggregate whose applicable index constraint is dynamic. (This was an extension to Ada 83). Check that index choices are within the applicable index constraint for array aggregates with others choices. C450001 Check that operations on modular types perform correctly. Check that loops over the range of a modular type do not over or under run the loop. C452001 For a type extension, check that predefined equality is defined in terms of the primitive equals operator of the parent type and any tagged components of the extension part. For other composite types, check that the primitive equality operator of any matching tagged components is used to determine equality of the enclosing type. For private types, check that predefined equality is defined in terms of the user-defined (primitive) operator of the full type if the full type is tagged. The partial view of the type may be tagged or untagged. Check that predefined equality for a private type whose full view is untagged is defined in terms of the predefined equality operator of its full type. C455001 Check that universal fixed multiplying operators can be used without a conversion in contexts where the result type is determined. C460001 Check that if the target type of a type conversion is a general access type, Program_Error is raised if the accessibility level of the operand type is deeper than that of the target type. Check for the case where the operand is an access parameter. Check for cases where the actual corresponding to the access parameter is: (a) An allocator. (b) An expression of a named access type. (c) Obj'Access. C460002 Check that if the target type of a type conversion is a general access type, Program_Error is raised if the accessibility level of the operand type is deeper than that of the target type. Check for the case where the operand is an access parameter, and the actual corresponding to the access parameter is another access parameter. C460004 Check that if the operand type of a type conversion is class-wide, Constraint_Error is raised if the tag of the operand does not identify a specific type that is covered by or descended from the target type. C460005 Check that, for a view conversion of a tagged type that is the left side of an assignment statement, the assignment assigns to the corresponding part of the object denoted by the operand. C460006 Check that a view conversion to a tagged type is permitted in the prefix of a selected component, an object renaming declaration, and (if the operand is a variable) on the left side of an assignment statement. Check that such a renaming or assignment does not change the tag of the operand. Check that, for a view conversion of a tagged type, each nondiscriminant component of the new view denotes the matching component of the operand object. Check that reading the value of the view yields the result of converting the value of the operand object to the target subtype. C460007 Check that, in a numeric type conversion, if the target type is an integer type and the operand type is real, the result is rounded to the nearest integer, and away from zero if the result is exactly halfway between two integers. Check for static and non-static type conversions. C460008 Check that conversion to a modular type raises Constraint_Error when the operand value is outside the base range of the modular type. C460009 Check that Constraint_Error is raised in cases of null arrays when: 1. an assignment is made to a null array if the length of each dimension of the operand does not match the length of the corresponding dimension of the target subtype. 2. an array actual parameter does not match the length of corresponding dimensions of the formal in out parameter where the actual parameter has the form of a type conversion. 3. an array actual parameter does not match the length of corresponding dimensions of the formal out parameter where the actual parameter has the form of a type conversion. C460010 Check that, for an array aggregate without an others choice assigned to an object of a constrained array subtype, Constraint_Error is not raised if the length of each dimension of the aggregate equals the length of the corresponding dimension of the target object, even if the bounds of the corresponding index ranges do not match. C460011 Check that conversion of a decimal type to a modular type raises Constraint_Error when the operand value is outside the base range of the modular type. Check that a conversion of a decimal type to an integer type rounds correctly. C460012 Check that the view created by a view conversion is constrained if the target subtype is indefinite. (Defect Report 8652/0017, Technical Corrigendum 4.6(54/1)). C460A01 Check that if the target type of a type conversion is a general access type, Program_Error is raised if the accessibility level of the operand type is deeper than that of the target type. Check for cases where the type conversion occurs in an instance body, and the operand type is passed as an actual during instantiation. C460A02 Check that if the target type of a type conversion is a general access type, Program_Error is raised if the accessibility level of the operand type is deeper than that of the target type. Check for cases where the type conversion occurs in an instance body, and the operand type is declared inside the instance or is the anonymous access type of an access parameter or access discriminant. C490001 Check that, for a real static expression that is not part of a larger static expression, and whose expected type T is a floating point type that is not a descendant of a formal scalar type, the value is rounded to the nearest machine number of T if T'Machine_Rounds is true, and is truncated otherwise. Check that if rounding is performed, and the value is exactly halfway between two machine numbers, the rounding is performed away from zero. C490002 Check that, for a real static expression that is not part of a larger static expression, and whose expected type T is an ordinary fixed point type that is not a descendant of a formal scalar type, the value is rounded to the nearest integral multiple of the small of T if T'Machine_Rounds is true, and is truncated otherwise. Check that if rounding is performed, and the value is exactly halfway between two multiples of the small, the rounding is performed away from zero. C490003 Check that a static expression is legal if its evaluation fails no language-defined check other than Overflow_Check. Check that such a static expression is legal if it is part of a larger static expression, even if its value is outside the base range of the expected type. Check that if a static expression is part of the right operand of a short circuit control form whose value is determined by its left operand, it is not evaluated. Check that a static expression in a non-static context is evaluated exactly. C540001 Check that an expression in a case statement may be of a generic formal type. Check that a function call may be used as a case statement expression. Check that a call to a generic formal function may be used as a case statement expression. Check that a call to an inherited function may be used as a case statement expression even if its result type does not correspond to any nameable subtype. C631001 Check that if different forms of a name are used in the default expression of a discriminant part, the selector may be an operator symbol or a character literal. C640001 Check that the prefix of a subprogram call with an actual parameter part may be an implicit dereference of an access-to-subprogram value. Check that, for an access-to-subprogram type whose designated profile contains parameters of a tagged generic formal type, an access-to- subprogram value may designate dispatching and non-dispatching operations, and that dereferences of such a value call the appropriate subprogram. C641001 Check that actual parameters passed by reference are view converted to the nominal subtype of the formal parameter. C650001 Check that, for a function result type that is a return-by-reference type, Program_Error is raised if the return expression is a name that denotes an object view whose accessibility level is deeper than that of the master that elaborated the function body. Check for cases where the result type is: (a) A tagged limited type. (b) A task type. (c) A protected type. (d) A composite type with a subcomponent of a return-by-reference type (task type). C730001 Check that the full view of a private extension may be derived indirectly from the ancestor type (i.e., the parent type of the full type may be any descendant of the ancestor type). Check that, for a primitive subprogram of the private extension that is inherited from the ancestor type and not overridden, the formal parameter names and default expressions come from the corresponding primitive subprogram of the ancestor type, while the body comes from that of the parent type. Check both dispatching and non-dispatching cases. C730002 Check that the full view of a private extension may be derived indirectly from the ancestor type (i.e., the parent type of the full type may be any descendant of the ancestor type). Check that, for a primitive subprogram of the private extension that is inherited from the ancestor type and not overridden, the formal parameter names and default expressions come from the corresponding primitive subprogram of the ancestor type, while the body comes from that of the parent type. Check for a case where the parent type is derived from the ancestor type through a series of types produced by generic instantiations. Examine both the static and dynamic binding cases. C730003 Check that the characteristics of a type derived from a private extension (outside the scope of the full view) are those defined by the partial view of the private extension. In particular, check that a component of the derived type may be explicitly declared with the same name as a component declared for the full view of the private extension. Check that a component defined in the private extension of a type may be updated through a view conversion of a type derived from the type. C730004 Check that for a type declared in a package, descendants of the package use the full view of type. Specifically check that full view of the limited type is visible only in private descendants (children) and in the private parts and bodies of public descendants (children). Check that a limited type may be used as an out parameter outside the package that defines the type. C730A01 Check that a tagged type declared in a package specification may be passed as a generic formal (tagged) private type to a generic package declaration. Check that the formal type may be extended with a private extension in the generic package. Check that, in the instance, the private extension inherits the user-defined primitive subprograms of the tagged actual. C730A02 Check that a private extension (declared in a package specification) of a tagged type (declared in a different package specification) may be passed as a generic formal (tagged) private type to a generic package declaration. Check that the formal type may be further extended with a private extension in the generic package. Check that the (visible) components inherited by the "generic" extension are visible outside the generic package. Check that, in the instance, the private extension inherits the user-defined primitive subprograms of the tagged actual, including those inherited by the actual from its parent. C731001 Check that inherited operations can be overridden, even when they are inherited in a body. The test cases here are inspired by the AARM examples given in the discussion of AARM-7.3.1(7.a-7.v). This discussion was confirmed by AI95-00035. C760001 Check that Initialize is called for objects and components of a controlled type when the objects and components are not assigned explicit initial values. Check this for "simple" controlled objects, controlled record components and arrays with controlled components. Check that if an explicit initial value is assigned to an object or component of a controlled type then Initialize is not called. C760002 Check that assignment to an object of a (non-limited) controlled type causes the Adjust operation of the type to be called. Check that Adjust is called after copying the value of the source expression to the target object. Check that Adjust is called for all controlled components when the containing object is assigned. (Test this for the cases where the type of the containing object is controlled and noncontrolled; test this for initialization as well as assignment statements.) Check that for an object of a controlled type with controlled components, Adjust for each of the components is called before the containing object is adjusted. Check that an Adjust procedure for a Limited_Controlled type is not called by the implementation. C760007 Check that Adjust is called for the execution of a return statement for a function returning a result of a (non-limited) controlled type. Check that Adjust is called when evaluating an aggregate component association for a controlled component. Check that Adjust is called for the assignment of the ancestor expression of an extension aggregate when the type of the aggregate is controlled. C760009 Check that for an extension_aggregate whose ancestor_part is a subtype_mark (i.e. Typemark'( Subtype with Field => x, etc.) ) Initialize is called on all controlled subcomponents of the ancestor part; if the type of the ancestor part is itself controlled, the Initialize procedure of the ancestor type is called, unless that Initialize procedure is abstract. Check that the utilization of a controlled type for a generic actual parameter supports the correct behavior in the instantiated package. C760010 Check that explicit calls to Initialize, Adjust and Finalize procedures that raise exceptions propagate the exception raised, not Program_Error. Check this for both a user defined exception and a language defined exception. Check that implicit calls to initialize procedures that raise an exception propagate the exception raised, not Program_Error; Check that the utilization of a controlled type as the actual for a generic formal tagged private parameter supports the correct behavior in the instantiated software. C760011 Check that the anonymous objects of a controlled type associated with function results and aggregates are finalized no later than the end of the innermost enclosing declarative_item or statement. Also check this for function calls and aggregates of a noncontrolled type with controlled components. C760012 Check that record components that have per-object access discriminant constraints are initialized in the order of their component declarations, and after any components that are not so constrained. Check that record components that have per-object access discriminant constraints are finalized in the reverse order of their component declarations, and before any components that are not so constrained. C760013 Check that Initialize is not called for default-initialized subcomponents of the ancestor type of an extension aggregate. (Defect Report 8652/0021, Technical Corrigendum 7.6(11/1)). C761001 Check that controlled objects declared immediately within a library package are finalized following the completion of the environment task (and prior to termination of the program). C761002 Check that objects of a controlled type that are created by an allocator are finalized at the appropriate time. In particular, check that such objects are not finalized due to completion of the master in which they were allocated if the corresponding access type is declared outside of that master. Check that Unchecked_Deallocation of a controlled object causes finalization of that object. C761003 Check that an object of a controlled type is finalized when the enclosing master is complete. Check this for controlled types where the derived type has a discriminant. Check this for subprograms of abstract types derived from the types in Ada.Finalization. Check that finalization of controlled objects is performed in the correct order. In particular, check that if multiple objects of controlled types are declared immediately within the same declarative part then type are finalized in the reverse order of their creation. C761004 Check that an object of a controlled type is finalized with the enclosing master is complete. Check that finalization occurs in the case where the master is left by a transfer of control. Specifically check for types where the derived types do not have discriminants. Check that finalization of controlled objects is performed in the correct order. In particular, check that if multiple objects of controlled types are declared immediately within the same declarative part then they are finalized in the reverse order of their creation. C761005 Check that deriving abstract types from the types in Ada.Finalization does not negatively impact the implicit operations. Check that an object of a controlled type is finalized when the enclosing master is complete. Check that finalization occurs in the case where the master is left by a transfer of control. Check this for controlled types where the derived type has a discriminant. Check this for cases where the type is defined as private, and the full type is derived from the types in Ada.Finalization. Check that finalization of controlled objects is performed in the correct order. In particular, check that if multiple objects of controlled types are declared immediately within the same declarative part then type are finalized in the reverse order of their creation. C761006 Check that Program_Error is raised when: * an exception is raised if Finalize invoked as part of an assignment operation; or * an exception is raised if Adjust invoked as part of an assignment operation, after any other adjustment due to be performed are performed; or * an exception is raised if Finalize invoked as part of a call on Unchecked_Deallocation, after any other finalizations to be performed are performed. C761007 Check that if a finalize procedure invoked by a transfer of control due to selection of a terminate alternative attempts to propagate an exception, the exception is ignored, but any other finalizations due to be performed are performed. C761008 (This test has been removed and replaced by C761011) Check that when an exception occurs in a Finalize operation invoked by a "normal" transfer of control (exit, return, goto), Program_Error is raised no earlier than after the finalization of the master being finalized when the exception occurred, and no later than the point where normal execution would have continued. Check that other finalizations due to be performed are performed prior to raising Program_Error. Check that for Finalize invoked by a transfer of control due to an exception, any other finalizations due to be performed for the same master are performed, then Program_Error is raised immediately after leaving the master. Check that other finalizations are performed first. Check that no other processing may occur after leaving the master. C761009 (This test has been removed) Check that when an exception occurs in a Finalize operation invoked by the transfer of control of a requeue statement, Program_Error is raised no earlier than after the finalization of the master being finalized when the exception occurred, and no later than the point where normal execution would have continued. Check that other finalizations due to be performed are performed prior to raising Program_Error. C761010 Check the requirements of the new 7.6.1(20.1/1) from Technical Corrigendum 1 (originally discussed as AI95-00083). This new paragraph requires that the initialization of an object with an aggregate does not involve calls to Adjust. C761011 Check that if a Finalize propagates an exception, other Finalizes due to be performed are performed. Case 1: A Finalize invoked due to the end of execution of a master. (Defect Report 8652/0023, as reflected in Technical Corrigendum 1). Case 2: A Finalize invoked due to finalization of an anonymous object. (Defect Report 8652/0023, as reflected in Technical Corrigendum 1). Case 3: A Finalize invoked due to the transfer of control due to an exit statement. Case 4: A Finalize invoked due to the transfer of control due to a goto statement. Case 5: A Finalize invoked due to the transfer of control due to a return statement. Case 6: A Finalize invoked due to the transfer of control due to raises an exception. C761012 Check that an anonymous object is finalized with its enclosing master if a transfer of control or exception occurs prior to performing its normal finalization. (Defect Report 8652/0023, as reflected in Technical Corrigendum 1, 7.6.1(13.1/1)). C840001 Check that, for the type determined by the subtype mark of a use type clause, the declaration of each primitive operator is use-visible within the scope of the clause, even if explicit operators with the same names as the type's operators are declared for the subtype. Check that a call to such an operator executes the body of the type's operation. C854001 Check that a subprogram declaration can be completed by a subprogram renaming declaration. In particular, check that such a renaming-as-body can be given in a package body to complete a subprogram declared in the package specification. Check that calls to the subprogram invoke the body of the renamed subprogram. Check that a renaming allows a copy of an inherited or predefined subprogram before overriding it later. Check that renaming a dispatching operation calls the correct body in case of overriding. C854002 Check the requirements of the new 8.5.4(8.A) from Technical Corrigendum 1 (originally discussed as AI95-00064). This paragraph requires an elaboration check on renamings-as-body: even if the body of the ultimately-called subprogram has been elaborated, the check should fail if the renaming-as-body itself has not yet been elaborated. C854003 Check that a renaming-as-body used before the subprogram is frozen only requires mode conformance. (Defect Report 8652/0028, as reflected in Technical Corrigendum 1, RM95 8.5.4(5/1)). C910001 Check that tasks may have discriminants. Specifically, check where the subtype of the discriminant is a discrete subtype and where it is an access subtype. Check the case where the default values of the discriminants are used. C910002 Check that the contents of a task object include the values of its discriminants. Check that selected_component notation can be used to denote a discriminant of a task. C910003 Check that task discriminants that have an access subtype may be dereferenced. Note that discriminants in Ada 83 never can be dereferenced with selection or indexing, as they cannot have an access type. C930001 Check when a dependent task and its master both terminate as a result of a terminate alternative that finalization is performed and that the finalization is performed in the proper order. C940001 Check that a protected object provides coordinated access to shared data. Check that it can be used to sequence a number of tasks. Use the protected object to control a single token for which three tasks compete. Check that only one task is running at a time and that all tasks get a chance to run sometime. C940002 Check that a protected object provides coordinated access to shared data. Check that it can implement a semaphore-like construct using a parameterless procedure which allows a specific maximum number of tasks to run and excludes all others C940004 Check that a protected record can be used to control access to resources (data internal to the protected record). C940005 Check that the body of a protected function can have internal calls to other protected functions and that the body of a protected procedure can have internal calls to protected procedures and to protected functions. C940006 Check that the body of a protected function can have external calls to other protected functions and that the body of a protected procedure can have external calls to protected procedures and to protected functions. C940007 Check that the body of a protected function declared as an object of a given type can have internal calls to other protected functions and that a protected procedure in such an object can have internal calls to protected procedures and to protected functions. C940010 Check that if an exception is raised during the execution of an entry body it is propagated back to the caller C940011 Check that, in the body of a protected object created by the execution of an allocator, external calls to other protected objects via the access type are correctly performed C940012 Check that a protected object can have discriminants C940013 Check that items queued on a protected entry are handled FIFO and that the 'count attribute of that entry reflects the length of the queue. C940014 Check that as part of the finalization of a protected object each call remaining on an entry queue of the objet is removed from its queue and Program_Error is raised at the place of the corresponding entry_call_statement. C940015 Check that the component_declarations of a protected_operation are elaborated in the proper order. Check that per-object constraints are elaborated for each object. C940016 Check that an Unchecked_Deallocation of a protected object performs the required finalization on the protected object. C940A03 Check that a protected object provides coordinated access to shared data. Check that it can implement a semaphore-like construct controlling access to shared data through procedure parameters to allow a specific maximum number of tasks to run and exclude all others. C951001 Check that two procedures in a protected object will not be executed concurrently. C951002 Check that an entry and a procedure within the same protected object will not be executed simultaneously. C953001 Check that if the evaluation of an entry_barrier condition propagates an exception, the exception Program_Error is propagated to all current callers of all entries of the protected object. C953002 Check that the servicing of entry queues of a protected object continues until there are no open entries with queued calls and that this takes place as part of a single protected operation. C953003 Check that the servicing of entry queues of a protected object continues until there are no open entries with queued (or requeued) calls and that internal requeues are handled as part of a single protected operation. C954001 Check that a requeue statement within an entry_body with parameters may requeue the entry call to a protected entry with a subtype- conformant parameter profile. Check that, if the call is queued on the new entry's queue, the original caller remains blocked after the requeue, but the entry_body containing the requeue is completed. C954010 Check that a requeue within an accept statement does not block. This test us