


                 VHDL Correct Error Test Objectives



INTRODUCTION

This document outlines the test objectives and corresponding test file
names for those tests comprising the "correct" portion of the test
suite.  These tests (689 total) were provided by Intermetrics, Inc., and
are intended to test features of VHDL which should both compile and simulate
correctly without error.

The following is organized by sections as they appear in the IEEE Standard
VHDL Language Reference Manual 1076-1987; note that sections for which no 
tests exist have been omitted.  Objective entries within each section
consist of an objective number (a sequential number with respect to each
LRM section, enclosed in brackets '[]'), objective description, and a list
of the correct test files which address the objective.

All correct test file names take on the form "ctXXXXX.vhd" where "XXXXX"
is a unique five digit integer beginning with "00001".  Included in each
test is a preamble which among other things includes a list of objectives
covered by the test (notated by LRM section number and objective number;
for example "1.1 (2)" denotes objective number 2 in section 1.1), and
the required design unit ordering (useful for the model generation stage
in the Intermetrics' toolset).

The correct tests depend on the existence of the three types packages
respectively defined in the files "standard_types.vhd",
"generic_standard_types.vhd", and "arithmetic.vhd".  Therefore these
files must be compiled (analyzed and model generated) prior to running
any of the correct tests; this may be done simply by including the "u"
option (do utilities first) when invoking the validation command file
found under the "tools" directory included as part of this tape.


TEST OBJECTIVES


1.1  ENTITY DECLARATIONS 
 
    Objective: [1] Verify that an entity declaration may have one or more
                   architecture bodies associated with it.
    Test(s)  : ct00001.vhd
 
    Objective: [2] Verify that the "begin entity_statement_part" is optional. 
    Test(s)  : ct00002.vhd
 
    Objective: [3] Verify that an entity name following the "end" keyword of 
                   the entity declaration is optional.   
    Test(s)  : ct00004.vhd
 
 
1.1.1  ENTITY HEADER 
 
    Objective: [1] Verify that the formal generic clause in an entity header is 
                   optional.   
    Test(s)  : ct00005.vhd
 
    Objective: [2] Verify that the formal port clause in an entity header is 
                   optional.   
    Test(s)  : ct00006.vhd

 
1.1.1.1  GENERICS 
 
    Objective: [1] Verify that when no actual is associated with a given formal 
                   generic, then the value of the default expression is the 
                   value of the generic.   
    Test(s)  : ct00007.vhd
               ct00010.vhd
               ct00011.vhd
               ct00012.vhd
 
    Objective: [2] Verify that a generic may be any of the predefined types: 
                   BIT, BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, STRING
                   or TIME. 
    Test(s)  : ct00013.vhd
               ct00014.vhd
               ct00015.vhd
               ct00016.vhd
 
    Objective: [3] Verify that a generic may be a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and 
                   floating (sub)type with a locally static range. 
    Test(s)  : ct00013.vhd
 
    Objective: [4] Verify that a generic may be a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and 
                   floating (sub)type with a static range which is not locally
                   static. 
    Test(s)  : ct00015.vhd
 
    Objective: [5] Verify that a generic may be a record, array or nested 
                   record-array type of locally static size. 
    Test(s)  : ct00014.vhd
 
    Objective: [6] Verify that a generic may be a record, array or nested 
                   record-array type of static size (but not locally static). 
    Test(s)  : ct00016.vhd
 
 
1.1.1.2  PORTS 
 
    Objective: [1] Verify that the associated actual port for a formal port of 
                   mode "linkage" may be of any mode.   
    Test(s)  : ct00017.vhd
 
    Objective: [2] Verify that a port of mode "in" with a default expression
                   may be unconnected.   
    Test(s)  : ct00020.vhd
               ct00021.vhd
               ct00022.vhd
               ct00023.vhd
 
    Objective: [3] Verify that a port of mode other than mode "in" which is not 
                   an unconstrained array type may be unconnected.   
    Test(s)  : ct00250.vhd
               ct00251.vhd
               ct00252.vhd
               ct00253.vhd
               ct00703.vhd
               ct00704.vhd

    Objective: [4] Verify that a port may be any of the predefined types:  BIT, 
                   BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, STRING or 
                   TIME. 
    Test(s)  : ct00024.vhd
               ct00025.vhd
               ct00227.vhd
               ct00228.vhd
               ct00231.vhd
               ct00232.vhd
               ct00235.vhd
               ct00236.vhd
               ct00239.vhd
               ct00240.vhd
 
    Objective: [5] Verify that a port may be a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type or floating 
                   (sub)type with a locally static range. 
    Test(s)  : ct00024.vhd
               ct00227.vhd
               ct00231.vhd
               ct00235.vhd
               ct00239.vhd
 
    Objective: [6] Verify that a port may be a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type or floating 
                   (sub)type with a static range which is not locally static. 
    Test(s)  : ct00225.vhd
               ct00229.vhd
               ct00233.vhd
               ct00237.vhd
               ct00241.vhd
 
    Objective: [7] Verify that a port may be a record, array or nested 
                   record-array type of locally static size. 
    Test(s)  : ct00025.vhd
               ct00228.vhd
               ct00232.vhd
               ct00236.vhd
               ct00240.vhd
 
    Objective: [8] Verify that a port may be a record, array or nested 
                   record-array type of static size (but non-locally static). 
    Test(s)  : ct00226.vhd
               ct00230.vhd
               ct00234.vhd
               ct00238.vhd
               ct00242.vhd
 
 
1.1.2  ENTITY DECLARATIVE PART 
 
    Objective: [1] Verify that the following items may be present in an entity 
                   declarative part:  subprogram declaration, subprogram body, 
                   type declaration, subtype declaration, constant declaration, 
                   signal declaration, file declaration, alias declaration, 
                   attribute declaration, label declaration, attribute 
                   specification, disconnection specification and use clause. 
    Test(s)  : ct00248.vhd
                    
 
    Objective: [2] Verify that no declarative items need be present in an
                   entity declarative part.   
    Test(s)  : ct00255.vhd
 
    Objective: [3] Verify that declarative items in the entity declarative part 
                   of an entity declaration are visible within the 
                   corresponding bodies.   
    Test(s)  : ct00248.vhd
 
 
1.1.3  ENTITY STATEMENT PART 
 
    Objective: [1] Verify that the concurrent statements present in the entity 
                   statement part are common to each design entity with this 
                   interface.   
    Test(s)  : ct00254.vhd
               ct00257.vhd

    Objective: [2] Verify that no concurrent statement need appear in an entity 
                   statement part.   
    Test(s)  : ct00256.vhd

    Objective: [3] Verify that the entity statement part may contain the 
                   following concurrent statements:  concurrent assertion 
                   statement, concurrent procedure call and/or process 
                   statement.   
    Test(s)  : ct00257.vhd
 
 
1.2  ARCHITECTURE BODIES 
 
    Objective: [1] Verify that a name following the "end" keyword in an 
                   architecture body is optional.   
    Test(s)  : ct00258.vhd
 
    Objective: [2] Verify that different architecture bodies associated with 
                   different entity declarations may have the same name.   
    Test(s)  : ct00259.vhd
 
 
1.2.1  ARCHITECTURE DECLARATIVE PART 
 
    Objective: [1] Verify that each of the following items may appear in an 
                   architecture declarative part:  subprogram declaration, 
                   subprogram body, type declaration, subtype declaration, 
                   constant declaration, signal declaration, file declaration, 
                   alias declaration, component, declaration, attribute 
                   declaration, label declaration, attribute specification, 
                   configuration specification, disconnection specification,
                   use clause.   
    Test(s)  : ct00261.vhd
 
1.2.2  ARCHITECTURE STATEMENT PART 
 
    Objective: [1] Verify that each of the following concurrent statements may 
                   appear in an architecture statement part:  block statement, 
                   process statement, assertion statement, concurrent procedure 
                   call statement, signal assignment statement, component 
                   instantiation statement, generate statement.   
    Test(s)  : ct00263.vhd
 
    Objective: [2] Verify that no concurrent statement need appear in an
                   architecture statement part.
    Test(s)  : ct00265.vhd
 
 
1.3  CONFIGURATION DECLARATIONS 
 
    Objective: [1] Verify that the name following the "end" keyword of the 
                   configuration declaration is optional.   
    Test(s)  : ct00266.vhd

    Objective: [2] Verify that use clauses and attribute specifications may be 
                   present in a configuration declarative part.   
    Test(s)  : ct00269.vhd
 
    Objective: [3] Verify that a configuration declarative part may be empty. 
    Test(s)  : ct00266.vhd
 
 
1.3.1  BLOCK CONFIGURATION 
 
    Objective: [1] Verify that use clauses are permitted after the block 
                   specification in a block configuration.   
    Test(s)  : ct00270.vhd

    Objective: [2] Verify that no configuration item need appear in a block 
                   configuration.   
    Test(s)  : ct00271.vhd
 
    Objective: [3] Verify that a configuration item in a block configuration
                   may be either another block configuration or a component 
                   configuration.   
    Test(s)  : ct00272.vhd
 
    Objective: [4] Verify that a block specification may be either an 
                   architecture name or a block statement label.   
    Test(s)  : ct00272.vhd

    Objective: [5] Verify that several configuration items may appear in a
                   block configuration and that configuration items may be
                   nested to some arbitrary depth (Check for a depth of 3).   
    Test(s)  : ct00272.vhd

    Objective: [6] Verify that when the scope of a declaration includes the end 
                   of a non-external block corresponding to a given block 
                   configuration, then the scope of that declaration extends to 
                   each configuration item contained in that block 
                   configuration.   
    Test(s)  : ct00274.vhd
 
    Objective: [7] Verify that for a given block configuration, block 
                   configurations and component configurations need not be 
                   explicitly given for each corresponding block statement and 
                   component instance appearing in the block statement 
                   corresponding to the given block configuration.   
    Test(s)  : ct00275.vhd
 
 
1.3.2  COMPONENT CONFIGURATION 
 
    Objective: [1] Verify that block configurations and component
                   configurations may be mutually nested to an arbitrary depth
                   (Check for a depth of 3).   
    Test(s)  : ct00276.vhd
 
    Objective: [2] Verify that the binding indication in a component 
                   configuration is optional.   
    Test(s)  : ct00277.vhd
 
    Objective: [3] Verify that a block configuration in a component 
                   configuration is optional.   
    Test(s)  : ct00276.vhd
 
    Objective: [4] Verify that a component configuration without a binding 
                   indication and a configuration specification can both apply 
                   to the same component instance.   
    Test(s)  : ct00277.vhd
 
 
2.1  SUBPROGRAM DECLARATIONS 
 
    Objective: [1] Verify that the formal parameter list is optional in a 
                   subprogram specification.   
    Test(s)  : ct00243.vhd
 
    Objective: [2] Verify that a subprogram specification may be either a 
                   procedure specification or a function specification.   
    Test(s)  : ct00243.vhd
 
    Objective: [3] Verify that an operator symbol appearing in a function 
                   specification may be any operator belonging to the six 
                   classes of operators defined in Section 7.2 of the VHDL LRM. 
    Test(s)  : ct00247.vhd
 
    Objective: [4] Verify that the case of letters in subprogram specifications 
                   which overload predefined operators is not significant.   
    Test(s)  : ct00247.vhd
 
    Objective: [5] Verify that procedures and functions may be called 
                   recursively.   
    Test(s)  : ct00244.vhd
 
    Objective: [6] Verify that a function may return any of the predefined 
                   types:  BIT, BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, 
                   STRING or TIME. 
    Test(s)  : ct00245.vhd

    Objective: [7] Verify that a function may return a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and
                   floating (sub)type with a locally static range. 
    Test(s)  : ct00474.vhd
 
    Objective: [8] Verify that a function may return a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and
                   floating (sub)type with a static range which is not locally
                   static. 
    Test(s)  : ct00476.vhd
 
    Objective: [9] Verify that a function may return a record, array or nested 
                   record-array type of locally static size. 
    Test(s)  : ct00474.vhd

    Objective: [10] Verify that a function may return a record, array or nested 
                   record-array type of static size (but not locally static). 
    Test(s)  : ct00476.vhd
 
    Objective: [11] Verify that a function may return a record, array or nested
                   record-array type of dynamic size.  This may be done by
                   nesting the function within a subprogram and having its
                   declaration depend on parameters passed into the subprogram.
    Test(s)  : ct00477.vhd
 
    Objective: [12] Verify that a function may return an access type or a file. 
    Test(s)  : ct00654.vhd
 
    Objective: [13] Verify that a function may return an unconstrained array. 
    Test(s)  : ct00245.vhd
 
 
2.1.1  FORMAL PARAMETERS 
 
    Objective: [1] Verify that the default object class for a subprogram formal 
                   parameter of mode "inout" or "out" is variable.   
    Test(s)  : ct00246.vhd

    Objective: [2] Verify that the modes "in", "inout" and "out" are allowed
                   for formal parameters of a procedure.   
    Test(s)  : ct00246.vhd
 
    Objective: [3] Verify that formal parameters of object class constant, 
                   variable and signal are allowed for a procedure.   
    Test(s)  : ct00246.vhd
 
    Objective: [4] Verify that the mode "in" is allowed for formal parameters
                   of a function.   
    Test(s)  : ct00246.vhd
 
    Objective: [5] Verify that formal parameters of object class constant and 
                   signal are allowed for a function.   
    Test(s)  : ct00246.vhd

    Objective: [6] Verify that a parameter may be any of the predefined types: 
                   BIT, BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, STRING
                   or TIME. 
    Test(s)  : ct00484.vhd
 
    Objective: [7] Verify that a parameter may be a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and
                   floating (sub)type with a locally static range. 
    Test(s)  : ct00484.vhd
 
    Objective: [8] Verify that a parameter may be a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and
                   floating (sub)type with a static range which is not locally
                   static. 
    Test(s)  : ct00485.vhd
 
    Objective: [9] Verify that a parameter may be a record, array or nested 
                   record-array type of locally static size. 
    Test(s)  : ct00484.vhd
 
    Objective: [10] Verify that a parameter may be a record, array or nested 
                   record-array type of static size (but not locally static). 
    Test(s)  : ct00485.vhd
 
    Objective: [11] Verify that a parameter may be a record, array or nested 
                   record-array type of dynamic size.  This may be done by 
                   nesting the corresponding subprogram within another 
                   subprogram and having the type of the parameter depend on 
                   parameters passed into the outer subprogram. 
    Test(s)  : ct00510.vhd
 
    Objective: [12] Verify that a parameter may be an unconstrained array. 
    Test(s)  : ct00484.vhd
 
    Objective: [13] Verify that a parameter may be an access type or a file. 
    Test(s)  : ct00654.vhd
 
 
2.1.1.1  CONSTANT AND VARIABLE PARAMETERS 
 
    Objective: [1] Verify that a parameter of scalar or access type is 
                   initialized at the start of each call to a subprogram.   
    Test(s)  : ct00267.vhd
 
    Objective: [2] Verify that for a parameter of mode "in" or "inout", the 
                   value of the actual parameter is copied into the subroutine. 
    Test(s)  : ct00267.vhd
                    
    Objective: [3] Verify that for a parameter of mode "inout" or "out", the 
                   value of the formal is copied into the associated actual 
                   parameter after completion of the subprogram body.   
    Test(s)  : ct00267.vhd
 
    Objective: [4] Verify that if copy is used by an implementation for passing 
                   arrays or records then a parameter of mode out must be 
                   initialized with the default initial value for the subtype
                   of the parameter.   
    Test(s)  : ct00267.vhd
 
 
2.1.1.2  SIGNAL PARAMETERS 
 
    Objective: [1] Verify that references to a signal in a subprogram body are 
                   equivalent to references to the actual signal - in
                   particular that a subprogram does not have to complete for
                   its signal assignments to take effect and that waiting on
                   signals within a subprogram is no different from waiting
                   within a process. 
    Test(s)  : ct00528.vhd
 
 
2.2  SUBPROGRAM BODIES

    Objective: [1] Verify that the following items may appear in a subprogram
                   declarative part: variable declaration, subprogram
                   declaration, subprogram body, type declaration, subtype
                   declaration, constant declaration, file declaration, alias
                   declaration, attribute declaration, attribute specification,
                   use clause.
    Test(s)  : ct00249.vhd

    Objective: [2] Verify that the designator appearing at the end of a
                   subprogram body is optional.
    Test(s)  : ct00249.vhd


    Objective: [3] Verify that any sequential statement may appear in a
                   subprogram statement part (except wait and signal
                   assignment statements in functions).
    Test(s)  : ct00249.vhd

    Objective: [4] Verify that a subprogram statement part need contain no
                   sequential statements.
    Test(s)  : ct00249.vhd

    Objective: [5] Verify that the declaration of a subprogram is optional.
    Test(s)  : ct00249.vhd

    Objective: [6] Verify that a function subprogram may contain a reference
                   to a constant object that is not declared within the
                   declarative region associated with the function.
    Test(s)  : ct00249.vhd

    Objective: [7] Verify that when a function is a parent of a given
                   procedure then that procedure may contain a reference
                   to a constant object that is not declared within the
                   declarative region associated with the function.
    Test(s)  : ct00249.vhd

    Objective: [8] Verify that dynamically sized structures may be declared
                   within a subroutine that contains a wait statement.
    Test(s)  : ct00249.vhd


2.3  SUBPROGRAM OVERLOADING 
 
    Objective: [1] Verify that any of:  name of subprogram, number of parameter 
                   associations, types and order of actual parameters, names of 
                   the formal parameters (if named association is used), and
                   the result type (for functions) may be used to disambiguate
                   an overloaded subroutine call (check both procedure and
                   function calls, and resolution functions specified in
                   subtype indications). 
    Test(s)  : ct00279.vhd
 
 
2.3.1  OPERATOR OVERLOADING 
 
    Objective: [1] Verify that the first parameter of an overloaded binary 
                   operator is associated with the left operand and the second 
                   parameter is associated with the right operand.   
    Test(s)  : ct00247.vhd
 
    Objective: [2] Verify that functions designating overloaded operator
                   symbols may be called using either function call notation
                   or operator notation.   
    Test(s)  : ct00247.vhd
 
 
2.4  RESOLUTION FUNCTIONS 
 
    Objective: [1] Verify that a resolution function may be recursive. 
    Test(s)  : ct00260.vhd
 
 
2.5  PACKAGE DECLARATIONS 
 
    Objective: [1] Verify that each of the following items may appear in a 
                   package declarative part:  subprogram declaration, type 
                   declaration, subtype declaration, constant declaration, 
                   signal declaration, file declaration, alias declaration, 
                   component declaration, attribute specification,
                   disconnection specification, use clause. 
    Test(s)  : ct00262.vhd
 
    Objective: [2] Verify that a package need not contain any declarative items.
    Test(s)  : ct00262.vhd
 
    Objective: [3] Verify that the name appearing after the "end" keyword in a 
                   package declaration is optional.   
    Test(s)  : ct00262.vhd
 
    Objective: [4] Verify that no package body need be given if no subprograms 
                   or deferred constants are declared in the package 
                   declaration.   
    Test(s)  : ct00262.vhd
 
 
2.6  PACKAGE BODIES 
 
    Objective: [1] Verify that the name following the "end" keyword in a
                   package body is optional.   
    Test(s)  : ct00262.vhd
 
    Objective: [2] Verify that each of the following items may appear in a 
                   package body declarative part:  subprogram declaration, 
                   subprogram body, type declaration, subtype declaration, 
                   constant declaration, file declaration, alias declaration, 
                   use clause.   
    Test(s)  : ct00262.vhd
 
    Objective: [3] Verify that no package body declarative item need appear in
                   a package body declarative part.   
    Test(s)  : ct00262.vhd
 
    Objective: [4] Verify that a name denoting a deferred constant may be used 
                   within the package declaration or corresponding package body 
                   in the default expression for a local generic, local port or 
                   formal parameter.   
    Test(s)  : ct00262.vhd
 
 
2.7  CONFORMANCE RULES 
 
    Objective: [1] Verify that changing a numeric literal's representation does 
                   not change the conformity of two specifications if the 
                   numeric literal's value does not change.   
    Test(s)  : ct00273.vhd
 
    Objective: [2] Verify that replacing a simple name by an expanded name in 
                   which the simple name is the selector and the meaning of the 
                   simple name in both places is given by the same declaration 
                   does not change the conformity of two specifications (check 
                   both subprogram specifications and deferred constant 
                   declarations).   
    Test(s)  : ct00273.vhd
 
    Objective: [3] Verify that the presence or absence of comments in one 
                   specification does not affect the conformity of two 
                   specifications (check both subprogram specifications and 
                   deferred constant declarations).   
    Test(s)  : ct00273.vhd
 
 
3.1  SCALAR TYPES 
 
    Objective: [1] Verify that a range constraint may be the range attribute. 
                   In particular, check that the range attribute may be applied 
                   to a formal in a subroutine which is an unconstrained array 
                   object (resulting in an unknown direction for the range 
                   before execution time). 
    Test(s)  : ct00264.vhd
 
    Objective: [2] Verify that a range may be a simple expression "to" another 
                   simple expression.   
    Test(s)  : ct00264.vhd
 
    Objective: [3] Verify that a range may be a simple expression "downto" 
                   another simple expression.   
    Test(s)  : ct00264.vhd
 
    Objective: [4] Verify that the range constraint on a subtype may be a 
                   descending range while the parent type is an ascending range.
                   Check that the range constraint on a subtype may be an 
                   ascending range while the parent type is a descending range. 
    Test(s)  : ct00264.vhd
 
 
3.1.1  ENUMERATION TYPES 
 
    Objective: [1] Verify that an enumeration type may consist of one identifier
                   or one character literal.   
    Test(s)  : ct00283.vhd
 
    Objective: [2] Verify that character literals and identifiers may be mixed 
                   in an enumeration type definition. 
    Test(s)  : ct00283.vhd
 
    Objective: [3] Verify that the position number of the nth listed enumeration
                   literal of an enumeration type is n-1.   
    Test(s)  : ct00283.vhd
 
    Objective: [4] Verify that enumeration literals may be overloaded.   
    Test(s)  : ct00283.vhd
 
    Objective: [5] Verify that an enumeration type definition defines an 
                   ascending range.   
    Test(s)  : ct00283.vhd
 

3.1.1.1  PREDEFINED ENUMERATION TYPES 
 
    Objective: [1] Verify that CHARACTER is predefined correctly:  check that 
                   each enumeration literal is defined and has the proper 
                   position number (or ordering), and that 
                   CHARACTER'POS(CHARACTER'RIGHT) = 127.   
    Test(s)  : ct00284.vhd
 
    Objective: [2] Verify that BIT is predefined correctly:  check that each 
                   enumeration literal is defined and has the proper position 
                   number (or ordering), and that BIT'POS(BIT'RIGHT) = 1.   
    Test(s)  : ct00284.vhd
 
    Objective: [3] Verify that BOOLEAN is predefined correctly:  check that each
                   enumeration literal is defined and has the proper position 
                   number (or ordering), and that BOOLEAN'POS(BOOLEAN'RIGHT) = 
                   1.   
    Test(s)  : ct00284.vhd
 
    Objective: [4] Verify that SEVERITY_LEVEL is predefined correctly:  check 
                   that each enumeration literal is defined and has the proper 
                   position number (or ordering), and that 
                   SEVERITY_LEVEL'POS(SEVERITY_LEVEL'RIGHT) = 3.   
    Test(s)  : ct00284.vhd

 
3.1.2  INTEGER TYPES 
 
    Objective: [1] Verify that the bounds in a range constraint for an integer 
                   type definition need not be of the same integer type.   
    Test(s)  : ct00286.vhd
 
    Objective: [2] Verify that -2147483647 and 2147483647 can be used in a range
                   constraint for an integer type definition.   
    Test(s)  : ct00286.vhd
 
    Objective: [3] Verify that the range in an integer type definition may be 
                   either an ascending or descending range. 
    Test(s)  : ct00286.vhd
 
 
3.1.2.1  PREDEFINED INTEGER TYPES 
 
    Objective: [1] Verify that INTEGER'LEFT <= -247483647 and INTEGER'RIGHT >= 
                   247483647.   
    Test(s)  : ct00286.vhd
 
 
3.1.3  PHYSICAL TYPES 
 
    Objective: [1] Verify that a secondary unit declaration need not appear in a
                   physical type definition.   
    Test(s)  : ct00290.vhd
 
    Objective: [2] Verify that an abstract literal is an optional part of a 
                   physical literal.   
    Test(s)  : ct00290.vhd
 
    Objective: [3] Verify that the bounds in a range constraint for a physical 
                   type definition need not be of the same integer type.   
    Test(s)  : ct00290.vhd
 
    Objective: [4] Verify that negative bounds are allowed in the range 
                   constraint for a physical type definition.   
    Test(s)  : ct00290.vhd
 
    Objective: [5] Verify that the relative order of secondary unit declarations
                   is not fixed as long as units are not used before they are 
                   declared. 
    Test(s)  : ct00290.vhd
 
    Objective: [6] Verify that a range constraint for a physical type definition
                   may include -2147483647 and 2147483647.   
    Test(s)  : ct00290.vhd
 
    Objective: [7] Verify that the range in a physical type definition may be 
                   either an ascending or descending range. 
    Test(s)  : ct00290.vhd
 
 
3.1.3.1  PREDEFINED PHYSICAL TYPES 
 
    Objective: [1] Verify that TIME is predefined - in particular that all units
                   are defined and are the correct multiples of the base unit. 
    Test(s)  : ct00291.vhd
 
 
3.1.4  FLOATING POINT TYPES 
 
    Objective: [1] Verify that the bounds of a range constraint that is used in 
                   a floating type definition need not be of the same floating 
                   point type.   
    Test(s)  : ct00292.vhd
 
    Objective: [2] Verify that a floating point type containing the range -1E38 
                   to 1E38 may be defined.   
    Test(s)  : ct00292.vhd
 
    Objective: [3] Verify that the range in a floating type definition may be 
                   either an ascending or descending range. 
    Test(s)  : ct00292.vhd
 
 
3.1.4.1  PREDEFINED FLOATING POINT TYPES 
 
    Objective: [1] Verify that the type REAL is predefined :  i.e.  It contains 
                   the range -1E38 to 1E38 and is such that REAL'LEFT < 
                   REAL'RIGHT.   
    Test(s)  : ct00292.vhd

 
3.2.1  ARRAY TYPES 
 
    Objective: [1] Verify that an unconstrained array definition may have 
                   several index subtype definitions of different discrete 
                   types.   
    Test(s)  : ct00296.vhd
 
    Objective: [2] Verify that a constrained array definition may have several 
                   index constraints of different discrete types.   
    Test(s)  : ct00296.vhd
 
    Objective: [3] Verify that a discrete range may be either a discrete subtype
                   indication or a range.   
    Test(s)  : ct00296.vhd
 
    Objective: [4] Verify that the index subtype definitions and discrete ranges
                   in index constraints may be any discrete type:  check for 
                   integer, bit, boolean, character and user defined enumeration
                   types. 
    Test(s)  : ct00296.vhd
 
 
3.2.1.1  INDEX CONSTRAINTS AND DISCRETE RANGES 
 
    Objective: [1] Verify that the index ranges of a variable or signal declared
                   via an object declaration are obtained from the corresponding
                   subtype indication.   
    Test(s)  : ct00600.vhd
 
    Objective: [2] Verify that the index ranges of an element of a record object
                   are obtained from the corresponding subtype indication.   
    Test(s)  : ct00600.vhd
 
    Objective: [3] Verify that the index ranges of an array element which is 
                   itself an array are obtained from the subtype indication in 
                   the corresponding array definition.   
    Test(s)  : ct00600.vhd
 
    Objective: [4] Verify that the index ranges of a constant declared by an 
                   object declaration are defined by the initial value if the 
                   subtype of the constant is unconstrained.   
    Test(s)  : ct00631.vhd
 
    Objective: [5] Verify that the index ranges of an attribute whose value is 
                   specified by an attribute specification are obtained from the
                   index ranges defined by the expression given in the 
                   specification if the subtype of the attribute is 
                   unconstrained.   
    Test(s)  : ct00631.vhd
 
    Objective: [6] Verify that the index ranges of an array object designated by
                   an access value are defined by the allocator that creates the
                   array object.   
    Test(s)  : ct00631.vhd
 
    Objective: [7] Verify that the index ranges of an interface object declared 
                   with a subtype indication that defines a constrained array 
                   subtype are obtained from that of the subtype.   
    Test(s)  : ct00631.vhd
 
    Objective: [8] Verify that the index ranges of a formal parameter of a 
                   subprogram that is of an unconstrained array type are 
                   obtained from those of the corresponding association element 
                   in the applicable subroutine call.   
    Test(s)  : ct00631.vhd
 
    Objective: [9] Verify that the index ranges of a formal generic of a design 
                   entity that is of an unconstrained array type are obtained 
                   from the corresponding association element in the generic map
                   clause of the applicable binding indication.   
    Test(s)  : ct00632.vhd
 
    Objective: [10] Verify that the index ranges of a formal port of a design 
                   entity that is of an unconstrained array type are obtained 
                   from the corresponding association element in the port map 
                   clause of the applicable binding indication.   
    Test(s)  : ct00632.vhd
 
    Objective: [11] Verify that the index ranges of a local generic of a 
                   component that is of an unconstrained array type are obtained
                   from the corresponding association element in the generic map
                   clause of the applicable component instantiation statement. 
    Test(s)  : ct00632.vhd
 
    Objective: [12] Verify that the index ranges of a formal generic of a 
                   component that is of an unconstrained array type are obtained
                   from the corresponding association element in the generic map
                   clause of the applicable component instantiation statement. 
    Test(s)  : ct00632.vhd
 
    Objective: [13] Verify that an index constraint may contain locally static 
                   bounds. 
    Test(s)  : ct00599.vhd
 
    Objective: [14] Verify that an index constraint may contain globally static 
                   bounds. 
    Test(s)  : ct00599.vhd
 
    Objective: [15] Verify that an index constraint may contain dynamic bounds. 
    Test(s)  : ct00599.vhd
 
 
3.2.1.2  PREDEFINED ARRAY TYPES 
 
    Objective: [1] Verify that the type STRING is predefined (i.e.  that the 
                   range is positive integers and the element type is predefined
                   type character).   
    Test(s)  : ct00297.vhd
 
    Objective: [2] Verify that the type BIT_VECTOR is predefined (i.e.  that the
                   range is the natural integers and the element type is 
                   predefined type bit).   
    Test(s)  : ct00297.vhd
 
 
3.2.2  RECORD TYPES 
 
    Objective: [1] Verify that a record type definition may contain a single 
                   element declaration.   
    Test(s)  : ct00307.vhd
 
    Objective: [2] Verify that a record type definition may contain several 
                   element declarations.   
    Test(s)  : ct00307.vhd
 
    Objective: [3] Verify that an identifier list in an element declaration may 
                   contain a single identifier.   
    Test(s)  : ct00307.vhd
 
    Objective: [4] Verify that an identifier list in an element declaration may 
                   contain several identifiers.   
    Test(s)  : ct00307.vhd
 
    Objective: [5] Verify that a record element of an array type may have 
                   globally static bounds. 
    Test(s)  : ct00307.vhd
 
    Objective: [6] Verify that a record element of an array type may have 
                   dynamic bounds (in a subroutine declarative part). 
    Test(s)  : ct00307.vhd
 

3.3  ACCESS TYPES 
 
    Objective: [1] Verify that the literal null is the default initial value of 
                   an access type.   
    Test(s)  : ct00308.vhd
 
    Objective: [2] Verify that the object designated by an access value is an 
                   object of class variable.   
    Test(s)  : ct00308.vhd
 
    Objective: [3] Verify that the subtype indication in an access type 
                   declaration may be any of the predefined types:  BIT, 
                   BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, STRING or 
                   TIME. 
    Test(s)  : ct00308.vhd
 
    Objective: [4] Verify that the subtype indication in an access type 
                   declaration may be a user defined enumeration type, integer 
                   type, physical type and floating type with a locally static 
                   range. 
    Test(s)  : ct00308.vhd
 
    Objective: [5] Verify that the subtype indication in an access type 
                   declaration may denote another access type, or a record, 
                   array or nested record-array type of locally static size. 
    Test(s)  : ct00308.vhd
 
    Objective: [6] Verify that the subtype indication in an access type 
                   declaration may denote another an array or nested 
                   record-array type of static size (but not locally static). 
    Test(s)  : ct00308.vhd
 
    Objective: [7] Verify that the subtype indication in an access type 
                   declaration may be an array or nested record-array type of 
                   dynamic size. 
    Test(s)  : ct00308.vhd

 
3.3.1  INCOMPLETE TYPE DECLARATIONS 
 
    Objective: [1] Verify that the subtype indication of an access type 
                   definition may be an incomplete type definition.   
    Test(s)  : ct00308.vhd
 
    Objective: [2] Verify that mutually recursive structures may defined via 
                   access types. 
    Test(s)  : ct00308.vhd
 
 
3.3.2  ALLOCATION AND DEALLOCATION OF OBJECTS 
 
    Objective: [1] Verify that the implicit procedure DEALLOCATE is declared for
                   each access type defined.   
    Test(s)  : ct00308.vhd
 
 
4.2  SUBTYPE DECLARATIONS 
 
    Objective: [1] Verify that a resolution function name may be part of a 
                   subtype indication and that subtypes so defined may be used 
                   in signal and non-signal declarations.   
    Test(s)  : ct00593.vhd
 
    Objective: [2] Verify that a constraint need not be present in a subtype 
                   indication.   
    Test(s)  : ct00594.vhd
 
    Objective: [3] Verify that a type mark in a subtype declaration may be 
                   either a type or a subtype name.   
    Test(s)  : ct00594.vhd
 
    Objective: [4] Verify that a constraint in a subtype declaration may be a 
                   range constraint, an index constraint or a size constraint. 
    Test(s)  : ct00594.vhd
 
    Objective: [5] Verify that the base type of a subtype is the base type of 
                   the type or subtype denoted by the type mark.   
    Test(s)  : ct00595.vhd
 
    Objective: [6] Verify that a subtype declaration does not define a new type.
                   Check this by using the equality operator on an object which 
                   is of type T and another object which is of subtype S of T. 
    Test(s)  : ct00595.vhd
 
    Objective: [7] Verify that the direction of a scalar subtype whose subtype 
                   indication contains a range is the direction of the range 
                   constraint. 
    Test(s)  : ct00596.vhd
 
    Objective: [8] Verify that the direction of a scalar subtype whose subtype 
                   indication does not contain a range is the direction of the 
                   type mark. 
    Test(s)  : ct00596.vhd
 
 
4.3.1  OBJECT DECLARATIONS 
 
    Objective: [1] Verify that a multiple object declaration is equivalent to a 
                   sequence of the corresponding number of single object 
                   declarations, and that the equivalent sequence is in the same
                   order as the identifier list.   
    Test(s)  : ct00655.vhd
 
    Objective: [2] Verify that a multiple interface object declaration is 
                   equivalent to a sequence of the corresponding number of 
                   single interface object declarations, and that the equivalent
                   sequence is in the same order as the identifier list.   
    Test(s)  : ct00657.vhd


4.3.1.1  CONSTANT DECLARATIONS 
 
    Objective: [1] Verify that an initial value expression is optional for 
                   deferred constants.   
    Test(s)  : ct00660.vhd
 
    Objective: [2] Verify that a constant may be of any of the predefined types:
                   BIT, BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, STRING or
                   TIME. 
    Test(s)  : ct00547.vhd
               ct00548.vhd
 
    Objective: [3] Verify that a constant may be of a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and floating
                   (sub)type with a locally static range. 
    Test(s)  : ct00547.vhd
 
    Objective: [4] Verify that a constant may be of a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and floating
                   (sub)type with a static range which is not locally static. 
    Test(s)  : ct00548.vhd
 
    Objective: [5] Verify that a constant may be of a record, array or nested 
                   record-array type of locally static size. 
    Test(s)  : ct00549.vhd
 
    Objective: [6] Verify that a constant may be of a record, array or nested 
                   record-array type of static size (but not locally static). 
    Test(s)  : ct00550.vhd
 
    Objective: [7] Verify that a constant may be of a record, array or nested 
                   record-array type of dynamic size (in a subroutine 
                   declarative part). 
    Test(s)  : ct00551.vhd

 
4.3.1.2  SIGNAL DECLARATIONS 
 
    Objective: [2] Verify that the default value of a scalar signal (or port of 
                   mode "out") without a source is given by the value in the 
                   (explicit or implicit) default expression.   
    Test(s)  : ct00671.vhd
               ct00672.vhd

    Objective: [3] Verify that a subelement of a composite signal (port) is also
                   a signal. 
    Test(s)  : ct00678.vhd

    Objective: [4] Verify that subelements of a composite resolved signal (port)
                   may be scheduled with independent waveforms. 
    Test(s)  : ct00678.vhd

    Objective: [5] Verify that a resolved signal (port) may have more than one 
                   source. 
    Test(s)  : ct00678.vhd

    Objective: [6] Verify that a signal may be of any of the predefined types: 
                   BIT, BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, STRING or
                   TIME. 
    Test(s)  : ct00552.vhd

    Objective: [7] Verify that a signal may be of a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and floating
                   (sub)type with a locally static range. 
    Test(s)  : ct00552.vhd

    Objective: [8] Verify that a signal may be of a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and floating
                   (sub)type with a static range which is not locally static. 
    Test(s)  : ct00553.vhd

    Objective: [9] Verify that a signal may be of a record, array or nested 
                   record-array type of locally static size. 
    Test(s)  : ct00554.vhd
 
    Objective: [10] Verify that a signal may be of a record, array or nested 
                   record-array type of static size (but not locally static). 
    Test(s)  : ct00555.vhd
 
 
4.3.1.3  VARIABLE DECLARATIONS 
 
    Objective: [1] Verify that the initial value expression in a variable 
                   declaration is optional.   
    Test(s)  : ct00668.vhd
               ct00669.vhd
               ct00670.vhd
 
    Objective: [2] Verify that the default initial value of a scalar variable of
                   type T is T'Left.   
    Test(s)  : ct00668.vhd
               ct00669.vhd
               ct00670.vhd
 
    Objective: [3] Verify that the default initial value of a composite variable
                   is the aggregation of the default initial values of its 
                   scalar subelements.   
    Test(s)  : ct00668.vhd
               ct00669.vhd
               ct00670.vhd
 
    Objective: [4] Verify that the default initial value of an access type is 
                   defined to be the value "null" for that type.   
    Test(s)  : ct00668.vhd
               ct00669.vhd
               ct00670.vhd
 
    Objective: [5] Verify that values of variables in a procedure with a wait 
                   statement may persist over one point in simulation time to 
                   another.   
    Test(s)  : ct00673.vhd
 
    Objective: [6] Verify that values of variables in a process persist over the
                   course of the whole simulation.   
    Test(s)  : ct00673.vhd
 
    Objective: [7] Verify that a variable may be of any of the predefined types:
                   BIT, BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, STRING or
                   TIME. 
    Test(s)  : ct00556.vhd
 
    Objective: [8] Verify that a variable may be of a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and floating
                   (sub)type with a locally static range. 
    Test(s)  : ct00556.vhd
 
    Objective: [9] Verify that a variable may be of a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and floating
                   (sub)type with a static range which is not locally static. 
    Test(s)  : ct00557.vhd
 
    Objective: [10] Verify that a variable may be of an access type or of a 
                   record, array or nested record-array type of locally static 
                   size. 
    Test(s)  : ct00558.vhd
               ct00587.vhd
               ct00588.vhd
               ct00589.vhd

    Objective: [11] Verify that a variable may be of a record, array or nested 
                   record-array type of static size (but not locally static). 
    Test(s)  : ct00559.vhd
               ct00590.vhd
 
    Objective: [12] Verify that a variable may be of a record, array or nested 
                   record-array type of dynamic size (in a subroutine 
                   declarative part). 
    Test(s)  : ct00560.vhd
               ct00591.vhd
 
 
4.3.3  INTERFACE DECLARATIONS 
 
    Objective: [1] Verify that an interface constant declaration may have one or
                   more identifiers in its identifier list.   
    Test(s)  : ct00642.vhd

    Objective: [2] Verify that in an interface constant declaration the 
                   "constant" keyword is optional (in a generic interface list 
                   or for parameters of mode in.)  
    Test(s)  : ct00643.vhd
 
    Objective: [3] Verify that in an interface constant declaration the "in" 
                   keyword is optional in its mode specification.   
 
    Test(s)  : ct00644.vhd

    Objective: [4] Verify that the initial value expression in an interface 
                   constant declaration is optional.   
    Test(s)  : ct00645.vhd
 
    Objective: [5] Verify that in an interface signal declaration the "signal" 
                   keyword is optional (in a port interface list.)  
    Test(s)  : ct00646.vhd

    Objective: [6] Verify that in an interface signal declaration the mode is 
                   optional.   
    Test(s)  : ct00647.vhd
 
    Objective: [7] Verify that the initial value expression in an interface 
                   signal declaration is optional.   
    Test(s)  : ct00648.vhd
 
    Objective: [8] Verify that the keyword "bus" is optional in an interface 
                   signal declaration.   
    Test(s)  : ct00648.vhd

    Objective: [9] Verify that in an interface variable declaration, the 
                   "variable" keyword is optional (in a subprogram interface 
                   list where the parameters are of mode inout or out.)  
    Test(s)  : ct00649.vhd
 
    Objective: [10] Verify that in an interface variable declaration the mode is
                   optional.   
    Test(s)  : ct00649.vhd
 
    Objective: [11] Verify that the initial value expression in an interface 
                   variable declaration is optional.   
    Test(s)  : ct00649.vhd
 
    Objective: [13] Verify that the value and attributes (except STABLE, QUIET, 
                   and DELAYED for signal subprogram parameters) of an interface
                   object of mode "in" may be read.   
    Test(s)  : ct00651.vhd
 
    Objective: [14] Verify that an interface object of mode out may be updated. 
    Test(s)  : ct00652.vhd
 
    Objective: [15] Verify that the attributes of an interface object of mode 
                   "out" may be read (except for attributes STABLE, QUIET, 
                   DELAYED, EVENT, ACTIVE, LAST_EVENT, LAST_ACTIVE and 
                   LAST_VALUE).   
    Test(s)  : ct00653.vhd

    Objective: [16] Verify that reading and updating the value of an interface 
                   object of mode "inout" is allowed.   
    Test(s)  : ct00658.vhd
 
    Objective: [17] Verify that reading the attributes of an interface object of
                   mode "inout" is allowed.   
    Test(s)  : ct00659.vhd
 
    Objective: [18] Verify that reading and updating the value of an interface 
                   object of mode "buffer" is allowed.   
    Test(s)  : ct00661.vhd
 
    Objective: [19] Verify that reading the attributes of an interface object of
                   mode "buffer" is allowed.   
    Test(s)  : ct00662.vhd
 
    Objective: [20] Verify that an interface object of mode "linkage" may appear
                   as an actual corresponding to an interface object of mode 
                   linkage.   
    Test(s)  : ct00664.vhd
 
 
4.3.3.1  INTERFACE LISTS 
 
    Objective: [1] Verify that an interface list may consist of a single 
                   element.   
    Test(s)  : ct00664.vhd
 
 
4.3.3.2  ASSOCIATION LISTS 
 
    Objective: [1] Verify that the formal part of an association element may be 
                   either a formal designator or a type conversion applied to a 
                   formal designator.   
    Test(s)  : ct00693.vhd
               ct00694.vhd
               ct00695.vhd
 
    Objective: [2] Verify that the actual part of an association element may be 
                   either an actual designator or a type conversion applied to 
                   an actual designator.   
    Test(s)  : ct00693.vhd
               ct00694.vhd
               ct00695.vhd

    Objective: [3] Verify that an actual designator may be an expression, a 
                   signal name, a variable name or the reserved word "open". 
    Test(s)  : ct00696.vhd
               ct00697.vhd
 
    Objective: [4] Verify that both positional and named association may be used
                   in an association list.   
    Test(s)  : ct00697.vhd
 
    Objective: [6] Verify that if an interface element for a formal generic 
                   includes a default expression then an association element for
                   that formal need not be given in an association list.   
    Test(s)  : ct00699.vhd
 
    Objective: [7] Verify that if an interface element for a formal parameter of
                   mode "in" contains a default expression, then an association 
                   element for that formal need not be given in an association 
                   list.   
    Test(s)  : ct00698.vhd
 
    Objective: [8] Verify that the subtype of the formal designator is permitted
                   to be different from the subtype of the actual designator as 
                   long as the base types match.   
    Test(s)  : ct00700.vhd

 
4.3.4  ALIAS DECLARATIONS 
 
    Objective: [1] Verify that the alias of a signal is a signal.   
    Test(s)  : ct00561.vhd
               ct00562.vhd
               ct00563.vhd
               ct00564.vhd
 
    Objective: [2] Verify that the alias of a variable is a variable.   
    Test(s)  : ct00561.vhd
               ct00562.vhd
               ct00563.vhd
               ct00564.vhd
               ct00565.vhd

    Objective: [3] Verify that the subtype indication and the type of the object
                   denoted by the name in an alias declaration need not be the 
                   same.   
    Test(s)  : ct00665.vhd
               ct00666.vhd

    Objective: [4] Verify that a reference to an element of an alias in which 
                   the object in the alias declaration is an array type is 
                   equivalent to a reference to the matching element in the 
                   array object.  Check for both single and multi-dimensional 
                   arrays.   
    Test(s)  : ct00665.vhd
 
    Objective: [5] Verify that a reference to a slice of an alias in which the 
                   object in the alias declaration is an array type is 
                   equivalent to a reference to the "matching slice" in the 
                   array object.  Check for both single and multi-dimensional 
                   arrays.   
    Test(s)  : ct00666.vhd
 
    Objective: [6] Verify that the name in an alias declaration may be a simple 
                   name, a selected name, an indexed name, a slice name and 
                   combinations thereof. 
    Test(s)  : ct00667.vhd

    Objective: [7] Verify that the name in an alias declaration may be a locally
                   static name. 
    Test(s)  : ct00665.vhd
               ct00666.vhd
 
    Objective: [8] Verify that the name in an alias declaration may be a 
                   globally static name. 
    Test(s)  : ct00665.vhd
               ct00666.vhd
 
    Objective: [9] Verify that an alias may be any of the predefined types: 
                   BIT, BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, STRING or
                   TIME. 
    Test(s)  : ct00561.vhd
 
    Objective: [10] Verify that an alias may be a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and floating
                   (sub)type with a locally static range. 
    Test(s)  : ct00561.vhd
 
    Objective: [11] Verify that an alias may be a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and floating
                   (sub)type with a static range which is not locally static. 
    Test(s)  : ct00562.vhd
 
    Objective: [12] Verify that an alias may be a record, array or nested 
                   record-array type of locally static size. 
    Test(s)  : ct00563.vhd

    Objective: [13] Verify that an alias may be a record, array or nested 
                   record-array type of static size (but not locally static). 
    Test(s)  : ct00564.vhd
 
    Objective: [14] Verify that an alias may be a record, array or nested 
                   record-array type of dynamic size (in a subroutine 
                   declarative part). 
    Test(s)  : ct00565.vhd
 
    Objective: [15] Verify that an alias may be an access type of dynamic size 
                   (in a subroutine declarative part). 
    Test(s)  : ct00592.vhd

 
4.4  ATTRIBUTE DECLARATIONS 
 
    Objective: [1] Verify that the subtype denoted by the type mark in an 
                   attribute declaration need not be constrained.   
    Test(s)  : ct00568.vhd
               ct00569.vhd
               ct00570.vhd
               ct00584.vhd
               ct00586.vhd
 
    Objective: [2] Verify that an attribute of an object is inherited by aliases
                   of that object.   
    Test(s)  : ct00677.vhd
 
    Objective: [3] Verify that an attribute may be any of the predefined types: 
                   BIT, BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, STRING or
                   TIME. 
    Test(s)  : ct00566.vhd
               ct00582.vhd
               ct00584.vhd

    Objective: [4] Verify that an attribute may be a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and floating
                   (sub)type with a locally static range. 
    Test(s)  : ct00566.vhd
               ct00568.vhd
               ct00582.vhd
 
    Objective: [5] Verify that an attribute may be a user defined enumeration 
                   (sub)type, integer (sub)type, physical (sub)type and floating
                   (sub)type with a static range which is not locally static. 
    Test(s)  : ct00567.vhd
               ct00583.vhd
 
    Objective: [6] Verify that an attribute may be a record, array or nested 
                   record-array type of locally static size. 
    Test(s)  : ct00568.vhd
               ct00584.vhd
 
    Objective: [7] Verify that an attribute may be a record, array or nested 
                   record-array type of static size (but not locally static). 
    Test(s)  : ct00569.vhd
               ct00585.vhd
 
    Objective: [8] Verify that an attribute may be a record, array or nested 
                   record-array type of dynamic size (in a subroutine 
                   declarative part). 
    Test(s)  : ct00570.vhd
               ct00586.vhd
 
 
4.5  COMPONENT DECLARATIONS 
 
    Objective: [1] Verify that the local generic clause in a component 
                   declaration is optional.   
    Test(s)  : ct00674.vhd
 
    Objective: [2] Verify that the local port clause in a component declaration 
                   is optional.   
    Test(s)  : ct00674.vhd
 
 
5.1  ATTRIBUTE SPECIFICATION 
 
    Objective: [1] Verify that an entity name list in an attribute specification
                   may contain one or more entity designators.   
    Test(s)  : ct00469.vhd
 
    Objective: [2] Verify that an entity designator in an attribute 
                   specification may be either a simple name or an operator 
                   symbol.   
    Test(s)  : ct00472.vhd
 
    Objective: [3] Verify that the entity class in an attribute specification 
                   can be any one of "entity", "procedure", "type", "signal", 
                   "label", "architecture", "function", "subtype", "variable", 
                   "configuration", "package", "constant", or "component".   
    Test(s)  : ct00473.vhd
 
    Objective: [4] Verify that an attribute specification with a list of entity 
                   designators applies to each entity listed in the entity name 
                   list.   
    Test(s)  : ct00469.vhd
 
    Objective: [5] Verify that an entity name list in an attribute specification
                   which is the keyword "others" applies to all entities of the 
                   specified class which are declared in the declarative part in
                   which the attribute specification itself appears and which 
                   have not appeared in previous attribute specifications in 
                   that declarative region.   
    Test(s)  : ct00481.vhd

    Objective: [6] Verify that an entity name list in an attribute specification
                   which is the keyword "all" applies to all entities of the 
                   specified class which are declared in the declarative part in
                   which the attribute specification itself appears.   
    Test(s)  : ct00268.vhd
 
    Objective: [7] Verify that an attribute associated with an overloaded 
                   subprogram has the effect of associating that attribute with 
                   each overloaded subprogram declared in the same declarative 
                   region.   
    Test(s)  : ct00482.vhd
 
    Objective: [8] Verify that the expression in an attribute declaration may be
                   locally static.   
    Test(s)  : ct00483.vhd
 
    Objective: [9] Verify that the expression in an attribute declaration may be
                   globally static.   
    Test(s)  : ct00486.vhd
 
    Objective: [10] Verify that the expression in an attribute declaration may
                   be dynamic.   
    Test(s)  : ct00487.vhd
 
 
5.2  CONFIGURATION SPECIFICATION 
 
    Objective: [1] Verify that one or many instantiation labels may appear in an
                   instantiation list of a configuration specification.   
    Test(s)  : ct00513.vhd
 
    Objective: [2] Verify that if the instantiation list is the reserved 
                   "others" then the configuration specification applies to each
                   instance of the specified component whose labels are declared
                   in the same declarative part in which the configuration 
                   specification itself appears and does not appear in a 
                   previous configuration specification.   
    Test(s)  : ct00514.vhd
 
    Objective: [3] Verify that if an instantiation list is the reserved word 
                   "all" then the configuration specification applies to each 
                   instance of the specified component whose labels are declared
                   in the same declarative part in which the configuration 
                   specification itself appears.   
    Test(s)  : ct00515.vhd
 

5.2.1  BINDING INDICATION 
 
    Objective: [1] Verify that a generic map aspect is optional after an entity 
                   aspect in a binding indication.   
    Test(s)  : ct00513.vhd
               ct00514.vhd
               ct00515.vhd
 
    Objective: [2] Verify that a port map aspect is optional in a binding 
                   indication.   
    Test(s)  : ct00513.vhd
               ct00514.vhd
               ct00515.vhd
 
5.2.1.1  ENTITY ASPECT 
 
    Objective: [1] Verify that the architecture identifier in an entity aspect 
                   with an entity name is optional.   
    Test(s)  : ct00516.vhd
 
    Objective: [2] Verify that an entity aspect may be open.   
    Test(s)  : ct00517.vhd
 
    Objective: [3] Verify that an entity aspect may be a configuration name. 
    Test(s)  : ct00518.vhd

 
6.3  SELECTED NAMES 
 
    Objective: [1] Verify that the suffix of a selected name may be a simple 
                   name, a character literal, an operator symbol or the reserved
                   word "all".   
    Test(s)  : ct00507.vhd
 
    Objective: [2] Verify that all primary units in a library are denoted by an 
                   expanded name whose prefix denotes a library and whose suffix
                   is the reserved word "all".   
    Test(s)  : ct00507.vhd
 
    Objective: [3] Verify that all entities declared in a package are denoted by
                   an expanded name whose prefix denotes a package and whose 
                   suffix is the reserved word "all".   
    Test(s)  : ct00507.vhd
 
    Objective: [4] Verify that an expanded name denotes an entity immediately 
                   within a named construct if the prefix denotes a construct 
                   that is an entity, an architecture, a subprogram, a block 
                   statement, a process statement or a loop statement and the 
                   suffix is the simple name, character literal or operator 
                   symbol of an entity whose declaration occurs immediately 
                   within that construct.   
    Test(s)  : ct00641.vhd
 
    Objective: [5] Verify that a prefix of a selected name may be a simple name,
                   operator symbol, selected name, indexed name, attribute name 
                   or function call. 
    Test(s)  : ct00598.vhd
 
 
6.4  INDEXED NAMES 
 
    Objective: [1] Verify that a prefix of an indexed name may be a simple name,
                   operator symbol, selected name, indexed name, attribute name,
                   slice name or function call. 
    Test(s)  : ct00346.vhd
 
    Objective: [2] Verify that index expressions in an indexed name may be 
                   locally static expressions. 
    Test(s)  : ct00346.vhd
 
    Objective: [3] Verify that index expressions in an indexed name may be 
                   globally static expressions. 
    Test(s)  : ct00346.vhd
 
    Objective: [4] Verify that index expressions in an indexed name may be 
                   dynamic expressions. 
    Test(s)  : ct00346.vhd
 
 
6.5  SLICE NAMES 
 
    Objective: [1] Verify that a slice of a signal is a signal.   
    Test(s)  : ct00347.vhd
 
    Objective: [2] Verify that a slice of a variable is a variable.   
    Test(s)  : ct00347.vhd
 
    Objective: [4] Verify that the discrete range of a slice may be null.   
    Test(s)  : ct00347.vhd
 
    Objective: [5] Verify that the bounds of a null slice need not belong to the
                   subtype of the index.   
    Test(s)  : ct00347.vhd
 
    Objective: [6] Verify that the discrete range of a slice may be a locally 
                   static range. 
    Test(s)  : ct00347.vhd
 
    Objective: [7] Verify that the discrete range of a slice may be a globally 
                   static range. 
    Test(s)  : ct00347.vhd
 
    Objective: [8] Verify that the discrete range of a slice may be a dynamic 
                   range. 
    Test(s)  : ct00347.vhd
 
 
6.6  ATTRIBUTE NAMES 
 
    Objective: [1] Verify that a prefix of an attribute name may be a simple 
                   name, operator symbol, selected name, indexed name, slice 
                   name or function call. 
    Test(s)  : ct00348.vhd
 
    Objective: [2] Verify that the prefix of an attribute name may be a locally 
                   static name. 
    Test(s)  : ct00348.vhd
 
    Objective: [3] Verify that the prefix of an attribute name may be a globally
                   static name. 
    Test(s)  : ct00348.vhd
 
    Objective: [4] Verify that the prefix of an attribute name may be a dynamic 
                   name. 
    Test(s)  : ct00348.vhd
 
 
7.1  EXPRESSIONS 
 
    Objective: [1] Verify that an unparenthesized expression may contain several
                   "and"s, "or"s or "xor"s in succession.   
    Test(s)  : ct00282.vhd
 
    Objective: [2] Verify that parentheses are not required around the operand 
                   of abs or not if the operand is a name, literal, function 
                   call, qualified expression, type conversion.   
    Test(s)  : ct00287.vhd
 
 
7.2  OPERATORS 
 
    Objective: [1] Verify that operators have the correct precedence, i.e.  (**,
                   abs, not), (*, /, mod, rem), (+, -), (+, -, &), (=, /=, <, 
                   <=, >, >=), (and, or, nand, nor, xor).   
 
    Objective: [2] Verify that operands are associated with operators of the 
                   same precedence level in textual order left to right.   
 
 
7.2.1  LOGICAL OPERATORS 
 
    Objective: [1] Verify that the logical operators and, or, nand, nor, xor and
                   not are predefined for predefined types BIT and BOOLEAN.   
    Test(s)  : ct00288.vhd
 
    Objective: [2] Verify that the logical operators and, or, nand, nor, xor and
                   not are predefined for any one dimensional array type whose 
                   element type is BIT or BOOLEAN.   
    Test(s)  : ct00289.vhd
 
    Objective: [3] Verify that the index ranges of operands of a logical 
                   operator which are one dimensional array types need not be 
                   the same.   
    Test(s)  : ct00293.vhd
 
    Objective: [4] Verify that the result type of each logical operator is the 
                   type of the left operand.   
    Test(s)  : ct00294.vhd
 
    Objective: [5] Verify that the index range of the result of a logical 
                   operator applied to operands of a one dimensional array type 
                   is the index range of the left operand.   
    Test(s)  : ct00294.vhd
 
    Objective: [6] Verify that for operators "and" and "nand" on operators of 
                   predefined types BIT and BOOLEAN, the right operand is not 
                   evaluated if the left operand evaluates to '1' or TRUE.   
    Test(s)  : ct00295.vhd
               ct00298.vhd
               ct00299.vhd
               ct00300.vhd
 
    Objective: [7] Verify that for operators "or" and "nor" on operators of 
                   predefined types BIT and BOOLEAN, the right operand is not 
                   evaluated if the left operand evaluates to '0' or FALSE. 
    Test(s)  : ct00295.vhd
               ct00298.vhd
               ct00299.vhd
               ct00300.vhd
 
    Objective: [9] Verify that logical operators may appear in locally static 
                   expressions. 
    Test(s)  : ct00288.vhd
               ct00289.vhd
 
    Objective: [10] Verify that logical operators may appear in globally static 
                   expressions. 
    Test(s)  : ct00288.vhd
               ct00289.vhd
 
    Objective: [11] Verify that logical operators may appear in non-static 
                   expressions. 
    Test(s)  : ct00288.vhd
               ct00289.vhd
 
 
7.2.2  RELATIONAL OPERATORS 
 
    Objective: [1] Verify that the result type of each relational operator is of
                   predefined type BOOLEAN.   
    Test(s)  : ct00306.vhd
               ct00309.vhd
               ct00310.vhd
 
    Objective: [2] Verify that "=" and "/=" are predefined for objects of any 
                   type:  check all predefined types and user defined records, 
                   arrays, access types, subtypes.   
    Test(s)  : ct00306.vhd
               ct00309.vhd
               ct00310.vhd
 
    Objective: [4] Verify that the index ranges of arrays need not be the same 
                   for two arrays to be equal.   
    Test(s)  : ct00311.vhd
 
    Objective: [5] Verify that array operands of = and /= need not have the same
                   length.   
    Test(s)  : ct00312.vhd
 
    Objective: [6] Verify that <, <=, >, >= are predefined for scalar types and 
                   for any discrete array type.   
    Test(s)  : ct00306.vhd
               ct00309.vhd
               ct00310.vhd
 
    Objective: [7] Verify that discrete array operands of <, <=, >, >= need not 
                   be of the same length (may also be null arrays).   
    Test(s)  : ct00312.vhd
 
    Objective: [8] Verify that the operands of relational operators need not be 
                   of the same subtype. 
    Test(s)  : ct00311.vhd

    Objective: [9] Verify that relational operators may appear in locally static
                   expressions. 
    Test(s)  : ct00306.vhd
               ct00309.vhd
               ct00310.vhd
 
    Objective: [10] Verify that relational operators may appear in globally 
                   static expressions. 
    Test(s)  : ct00306.vhd
               ct00309.vhd
               ct00310.vhd
 
    Objective: [11] Verify that relational operators may appear in non-static 
                   expressions. 
    Test(s)  : ct00306.vhd
               ct00309.vhd
               ct00310.vhd
 
 
7.2.3  ADDING OPERATORS 
 
    Objective: [1] Verify that "+" and "-" are predefined for any numeric type. 
    Test(s)  : ct00314.vhd
               ct00334.vhd
               ct00335.vhd
 
    Objective: [2] Verify that signs "+" and "-" are predefined for any numeric 
                   type.   
    Test(s)  : ct00314.vhd
               ct00334.vhd
               ct00335.vhd
 
    Objective: [3] Verify that if both operands of "&" are non-null arrays, then
                   the length of the result is the sum of the elements of the 
                   left and right operands, the direction of the result is the 
                   direction of the left operand and the elements of the left 
                   operand appear before the elements of the right operand in 
                   the result of a concatenation operation.   
    Test(s)  : ct00333.vhd
 
    Objective: [4] Verify that if both operands of "&" are one-dimensional 
                   arrays and the left operand is a null array, then the 
                   result's value and index range are those of the right 
                   operand.   
    Test(s)  : ct00426.vhd
 
    Objective: [5] Verify that if the right operand of "&" is a one dimensional 
                   array and the left operand is the element type, then the 
                   direction and left bound of the result are taken from the 
                   right operand, the size of the result is the size of the 
                   right operand(=n) + 1, the first n elements of the result are
                   the elements of the right operand and the last element of the
                   result is the left operand.   
    Test(s)  : ct00427.vhd
 
    Objective: [6] Verify that if the left operand of "&" is a one dimensional 
                   array and the right operand is the element type, then the 
                   direction and left bound of the result are taken from the 
                   left operand, the size of the result is the size of the left 
                   operand(=n) + 1, the last n elements of the result are the 
                   elements of the left operand and the first element of the 
                   result is the right operand.   
    Test(s)  : ct00427.vhd
 
    Objective: [7] Verify that both operands of "&" may be element types when 
                   the result type is known from context.   
    Test(s)  : ct00431.vhd
 
    Objective: [8] Verify that the operands of adding operators need not be of 
                   the same subtype. 
    Test(s)  : ct00314.vhd
               ct00334.vhd
               ct00335.vhd
               ct00432.vhd
               ct00459.vhd

    Objective: [9] Verify that "+", "-", "&", sign "+" and sign "-" may appear 
                   in locally static expressions. 
    Test(s)  : ct00314.vhd
               ct00333.vhd
               ct00334.vhd
               ct00335.vhd
               ct00426.vhd
               ct00427.vhd
               ct00431.vhd

    Objective: [10] Verify that "+", "-", "&", sign "+" and sign "-" may appear 
                   in globally static expressions. 
    Test(s)  : ct00314.vhd
               ct00333.vhd
               ct00334.vhd
               ct00335.vhd
               ct00426.vhd
               ct00427.vhd
               ct00431.vhd

    Objective: [11] Verify that "+", "-", "&", sign "+" and sign "-" may appear 
                   in non-static expressions. 
    Test(s)  : ct00333.vhd
               ct00426.vhd
               ct00427.vhd
               ct00431.vhd

7.2.4  MULTIPLYING OPERATORS 
 
    Objective: [1] Verify that "*", "/", "mod" and "rem" are predefined for 
                   operands which are both of type integer.   
    Test(s)  : ct00434.vhd
               ct00438.vhd
               ct00439.vhd
               ct00440.vhd
 
    Objective: [2] Verify that "*" and "/" are predefined for operands which are
                   both of floating point type. 
    Test(s)  : ct00443.vhd
               ct00444.vhd
 
    Objective: [4] Verify that the operands of multiplying operators may be of 
                   the same type and not of the same subtype. 
    Test(s)  : ct00434.vhd
               ct00438.vhd
               ct00439.vhd
               ct00440.vhd
 
    Objective: [5] Verify that multiplication of a value P of a physical type T 
                   by a value I of type integer is equivalent to T'Val(T'Pos(P) 
                   * I).   
    Test(s)  : ct00453.vhd
               ct00463.vhd
               ct00464.vhd
 
    Objective: [6] Verify that multiplication of a value P of a physical type T 
                   by a value F of type real is equivalent to 
                   T'Val(INTEGER(REAL(T'Pos(P)) * F)).   
    Test(s)  : ct00454.vhd
               ct00463.vhd
               ct00464.vhd
 
    Objective: [7] Verify that division of a value P of a physical type T by a 
                   value I of type integer is equivalent to T'Val(T'Pos(P) / I).
    Test(s)  : ct00455.vhd
               ct00463.vhd
               ct00464.vhd
 
    Objective: [8] Verify that division of a value P of a physical type T by a 
                   value F of type real is equivalent to 
                   T'Val(INTEGER(REAL(T'Pos(P)) / F)).   
    Test(s)  : ct00456.vhd
 
    Objective: [9] Verify that division of a value P1 of a physical type T by a 
                   value P2 of a physical type is equivalent to T'Pos(P1) / 
                   T'Pos(P2).   
    Test(s)  : ct00457.vhd
 
    Objective: [10] Verify that the result of an object of physical type divided
                   by another object of the same physical type is of type 
                   universal integer.   
    Test(s)  : ct00457.vhd
 
    Objective: [11] Verify that "*", "/", mod, and rem may appear in locally 
                   static expressions. 
    Test(s)  : ct00434.vhd
               ct00438.vhd
               ct00439.vhd
               ct00440.vhd
               ct00443.vhd
               ct00444.vhd
               ct00453.vhd
               ct00454.vhd
               ct00455.vhd
               ct00456.vhd
               ct00457.vhd
 
    Objective: [12] Verify that "*", "/", mod, and rem may appear in globally 
                   static expressions. 
    Test(s)  : ct00434.vhd
               ct00438.vhd
               ct00439.vhd
               ct00440.vhd
               ct00443.vhd
               ct00444.vhd
               ct00453.vhd
               ct00454.vhd
               ct00455.vhd
               ct00456.vhd
               ct00457.vhd
 
    Objective: [13] Verify that "*", "/", mod, rem may appear in non-static 
                   expressions. 
    Test(s)  : ct00434.vhd
               ct00438.vhd
               ct00439.vhd
               ct00440.vhd
               ct00443.vhd
               ct00444.vhd
               ct00453.vhd
               ct00454.vhd
               ct00455.vhd
               ct00456.vhd
               ct00457.vhd


7.2.5  MISCELLANEOUS OPERATORS 
 
    Objective: [1] Verify that the operator "abs" is predefined for all numeric 
                   types.   
    Test(s)  : ct00462.vhd
               ct00463.vhd
               ct00464.vhd
 
    Objective: [2] Verify that the operator "**" is predefined for a base of 
                   integer or floating point type and an exponent of predefined 
                   type INTEGER.   
    Test(s)  : ct00460.vhd
               ct00461.vhd
 
    Objective: [5] Verify that abs and "**" may appear in locally static 
                   expressions. 
    Test(s)  : ct00460.vhd
               ct00461.vhd
               ct00462.vhd
 
    Objective: [6] Verify that abs and "**" may appear in globally static 
                   expressions. 
    Test(s)  : ct00460.vhd
               ct00461.vhd
               ct00462.vhd
 
    Objective: [7] Verify that abs and "**" may appear in non-static 
                   expressions. 
    Test(s)  : ct00460.vhd
               ct00461.vhd
               ct00462.vhd
 
 
7.3.2  AGGREGATES 
 
    Objective: [1] Verify that an aggregate may consist of several element 
                   associations.   
    Test(s)  : ct00475.vhd
 
    Objective: [2] Verify that an aggregate may consist of a single element 
                   association.   
    Test(s)  : ct00475.vhd
 
    Objective: [3] Verify that an element association in an aggregate may 
                   contain several choices.   
    Test(s)  : ct00478.vhd
 
    Objective: [4] Verify that an element association in an aggregate may 
                   contain any form of choice as a single choice.   
    Test(s)  : ct00478.vhd
 
    Objective: [5] Verify that an element association in an aggregate may 
                   contain no choices.   
    Test(s)  : ct00478.vhd
 
    Objective: [6] Verify that choices may be a simple expression, discrete 
                   range, element simple name or the reserved word "others". 
    Test(s)  : ct00478.vhd
                    
    Objective: [7] Verify that both named and positional associations may be 
                   used in the same aggregate.   
    Test(s)  : ct00479.vhd
 
    Objective: [8] Verify that a name which could be interpreted either as a 
                   simple expression or an element simple name can occur as the 
                   choice in an element association in either a record aggregate
                   or an array aggregate. 
    Test(s)  : ct00478.vhd
 
 
7.3.2.2  ARRAY AGGREGATES 
 
    Objective: [1] Verify that a multi-dimensional array value may be specified 
                   as an array aggregate.   
    Test(s)  : ct00480.vhd
 
    Objective: [2] Verify that a string or bit string literal is allowed in an 
                   aggregate at the place of a one-dimensional array of a 
                   character type.   
    Test(s)  : ct00488.vhd
 
    Objective: [3] Verify that an array aggregate with an others choice may 
                   appear as an actual associated with a formal parameter of 
                   formal generic declared to be of a constrained array subtype.
    Test(s)  : ct00489.vhd
               ct00490.vhd
 
    Objective: [4] Verify that an array aggregate with an others choice may 
                   appear as the default expression of a port declared to be of 
                   a constrained array subtype.   
    Test(s)  : ct00491.vhd
               ct00492.vhd
 
    Objective: [5] Verify that an array aggregate with an others choice may 
                   appear as the result expression of a function whose result 
                   type is a constrained array subtype.   
    Test(s)  : ct00493.vhd
               ct00494.vhd
 
    Objective: [6] Verify that an array aggregate with an others choice may 
                   appear as a value expression in an assignment statement where
                   the target is a declared object whose subtype is a 
                   constrained array subtype.   
    Test(s)  : ct00495.vhd
               ct00496.vhd
 
    Objective: [7] Verify that an array aggregate with an others choice may 
                   appear as the expression defining the initial value of a 
                   constant or variable object of a constrained array subtype. 
    Test(s)  : ct00497.vhd
               ct00498.vhd
                    
    Objective: [8] Verify that an array aggregate with an others choice may 
                   appear as the expression defining initial value of drivers of
                   one or more signals in an default expression where the 
                   corresponding subtype is a constrained array subtype.   
    Test(s)  : ct00499.vhd
               ct00500.vhd
 
    Objective: [9] Verify that an array aggregate with an others choice may 
                   appear as the expression defining the value of an attribute 
                   in an attribute specification where the attribute is declared
                   to be of a constrained array subtype.   
    Test(s)  : ct00499.vhd
               ct00500.vhd

    Objective: [10] Verify that an array aggregate with an others choice may 
                   appear as the operand of a qualified expression whose type 
                   mark denotes a constrained array subtype.   
    Test(s)  : ct00503.vhd
 
    Objective: [11] Verify that an array aggregate with an others choice may 
                   appear as a subaggregate of a multi-dimensional aggregate 
                   where that aggregate appears in one of the contexts above. 
    Test(s)  : ct00489.vhd
               ct00490.vhd
               ct00491.vhd
               ct00492.vhd
               ct00493.vhd
               ct00494.vhd
               ct00495.vhd
               ct00496.vhd
               ct00497.vhd
               ct00498.vhd
               ct00499.vhd
               ct00500.vhd
               ct00501.vhd
               ct00503.vhd
 
    Objective: [12] Verify that if an aggregate does not appear in one of the 
                   above contexts then the direction of the index subtype of the
                   aggregate is the index subtype of the base type of the 
                   aggregate.   
    Test(s)  : ct00520.vhd
               ct00521.vhd
 
    Objective: [13] Verify that an aggregate that has named associations derives
                   its leftmost bound and rightmost bounds from the direction 
                   and the smallest and largest choices given (can do this by 
                   passing it to a function and using 'range). 
    Test(s)  : ct00521.vhd
 
    Objective: [15] Verify that the leftmost bound of an array aggregate that 
                   does not appear in one of the above contexts is given by 
                   S'Left where S is the index subtype of the base type of the 
                   array. 
    Test(s)  : ct00520.vhd
 
    Objective: [16] Verify that the rightmost bound of an array aggregate is 
                   determined by the direction of the index subtype and the 
                   number of elements. 
    Test(s)  : ct00520.vhd
               ct00521.vhd


7.3.3  FUNCTION CALLS 
 
    Objective: [1] Verify that an actual parameter list is optional in a 
                   function call.  As a special case check that the function 
                   call may be the prefix of an indexed name, selected name or 
                   slice name.   
    Test(s)  : ct00527.vhd
               ct00529.vhd
 
 
7.3.4  QUALIFIED EXPRESSIONS 
 
    Objective: [1] Verify that a qualified expression may have an expression or 
                   an aggregate as its operand.   
    Test(s)  : ct00531.vhd
               ct00532.vhd
               ct00537.vhd
               ct00544.vhd
               ct00545.vhd
 
 
7.3.5  TYPE CONVERSIONS 
 
    Objective: [1] Verify that the conversion of an operand of a given type to 
                   the type itself is allowed for any type - in particular for 
                   record types and access types. 
    Test(s)  : ct00679.vhd
 
    Objective: [2] Verify that the operand of a type conversion whose type mark 
                   is of an integer type may be either another integer type or a
                   floating point type.   
    Test(s)  : ct00680.vhd
               ct00681.vhd
               ct00682.vhd
 
    Objective: [4] Verify that the conversion of a floating point value that is 
                   not halfway between two integers to an integer type rounds to
                   the nearest integer.   
    Test(s)  : ct00680.vhd
               ct00681.vhd
               ct00682.vhd
 
 
7.3.6  ALLOCATORS 
 
    Objective: [2] Verify that the initial value of the created object for an 
                   allocator with a subtype indication is the default initial 
                   value for an explicitly declared variable of the designated 
                   subtype.   
    Test(s)  : ct00683.vhd
               ct00684.vhd
               ct00685.vhd
               ct00686.vhd
               ct00687.vhd
 
    Objective: [3] Verify that the initial value of the created object of an 
                   allocator with a qualified expression is the expression in 
                   the qualified expression.   
    Test(s)  : ct00688.vhd
               ct00689.vhd
               ct00690.vhd
               ct00691.vhd
               ct00692.vhd
 
    Objective: [4] Verify that an allocator may allocate any of the predefined 
                   types:  BIT, BIT_VECTOR, BOOLEAN, CHARACTER, INTEGER, REAL, 
                   STRING or TIME. 
    Test(s)  : ct00683.vhd
               ct00684.vhd
               ct00688.vhd
               ct00689.vhd
 
    Objective: [5] Verify that an allocator may allocate a user defined 
                   enumeration (sub)type, integer (sub)type, physical (sub)type 
                   and floating (sub)type with a locally static range. 
    Test(s)  : ct00683.vhd
               ct00688.vhd
 
    Objective: [6] Verify that an allocator may allocate a user defined 
                   enumeration (sub)type, integer (sub)type, physical (sub)type 
                   and floating (sub)type with a static range which is not 
                   locally static. 
    Test(s)  : ct00685.vhd
               ct00690.vhd
 
    Objective: [7] Verify that an allocator may allocate a record, array or 
                   nested record-array type of locally static size. 
    Test(s)  : ct00684.vhd
               ct00689.vhd
 
    Objective: [8] Verify that an allocator may allocate a record, array or 
                   nested record-array type of static size (but not locally 
                   static). 
    Test(s)  : ct00686.vhd
               ct00691.vhd
 
    Objective: [9] Verify that an allocator may allocate a record, array or 
                   nested record-array type of dynamic size. 
    Test(s)  : ct00687.vhd
               ct00692.vhd
 
 
8.1  WAIT STATEMENT 
 
    Objective: [1] Verify that the wait statement causes the suspension of a 
                   process statement or a procedure.   
    Test(s)  : ct00003.vhd
 
    Objective: [2] Verify that the sensitivity clause of a wait statement is
                   optional.
    Test(s)  : ct00008.vhd
 
    Objective: [3] Verify that the condition clause of a wait statement is
                   optional.
    Test(s)  : ct00008.vhd
 
    Objective: [4] Verify that the timeout clause of a wait statement is
                   optional.
    Test(s)  : ct00008.vhd
 
    Objective: [5] Verify that when no sensitivity clause appears in a wait 
                   statement, then the sensitivity set contains signals denoted 
                   by the longest static prefix of each signal name that appears
                   as a primary in the condition of the condition clause (if 
                   any).   
    Test(s)  : ct00197.vhd
               ct00198.vhd
               ct00199.vhd
               ct00200.vhd
               ct00201.vhd
               ct00202.vhd
               ct00203.vhd
               ct00204.vhd
               ct00205.vhd
               ct00206.vhd
               ct00207.vhd
               ct00208.vhd
               ct00209.vhd
               ct00210.vhd
               ct00211.vhd
               ct00212.vhd
               ct00213.vhd
               ct00214.vhd
               ct00215.vhd
               ct00216.vhd
               ct00217.vhd
               ct00218.vhd
               ct00219.vhd
               ct00220.vhd
               ct00221.vhd
               ct00222.vhd
               ct00223.vhd
               ct00224.vhd

    Objective: [6] Verify that the timeout clause "for (TIME'HIGH -
                   STANDARD.NOW)" is assumed for wait statements without
                   a timeout clause.
    Test(s)  : ct00008.vhd
 
    Objective: [7] Verify that a process will resume after the time of the 
                   timeout clause has expired.   
    Test(s)  : ct00009.vhd
 
    Objective: [8] Verify that a process will not resume if the time of the 
                   timeout clause has not expired and an event has occurred on a
                   signal in the sensitivity set but the condition evaluates to 
                   false.   
    Test(s)  : ct00018.vhd
 
    Objective: [9] Verify that a process will resume if an event has occurred on
                   a signal in the sensitivity set and the condition evaluates 
                   to true.   
    Test(s)  : ct00019.vhd

    Objective: [10] Verify that resuspension due to a condition being false does
                   not involve recalculating the time interval.   
    Test(s)  : ct00009.vhd
 
 
8.2  ASSERTION STATEMENT 
 
    Objective: [1] Verify that in the absence of a report expression the default
                   is "Assertion violation."  
    Test(s)  : ct00028.vhd
 
    Objective: [2] Verify that in the absence of a severity expression the 
                   default is ERROR.   
    Test(s)  : ct00028.vhd
 
    Objective: [3] Verify that both the report expression and the severity 
                   expression are optional.   
    Test(s)  : ct00028.vhd
    Objective: [4] Verify that the severity expression may evaluate to any of 
                   the values of the predefined type SEVERITY_LEVEL.   
    Test(s)  : ct00029.vhd
 
    Objective: [5] Verify that the report expression may be a complicated string
                   expression.   
    Test(s)  : ct00027.vhd

    Objective: [6] Verify that an assertion violation occurs when the assert 
                   condition evaluates to FALSE.   
    Test(s)  : ct00026.vhd
 
 
8.3  SIGNAL ASSIGNMENT STATEMENT 
 
    Objective: [1] Verify that the keyword "transport" is optional in a signal 
                   assignment statement.   
    Test(s)  : ct00131.vhd
               ct00132.vhd
               ct00133.vhd
               ct00134.vhd
               ct00135.vhd
               ct00136.vhd
               ct00137.vhd
               ct00138.vhd
               ct00139.vhd
               ct00140.vhd
               ct00141.vhd
               ct00142.vhd
               ct00143.vhd
               ct00144.vhd
               ct00145.vhd
               ct00146.vhd
               ct00147.vhd
               ct00148.vhd
               ct00149.vhd
               ct00150.vhd
               ct00151.vhd
               ct00152.vhd
               ct00153.vhd
               ct00154.vhd
               ct00155.vhd
               ct00156.vhd
               ct00157.vhd
               ct00158.vhd
               ct00159.vhd
               ct00160.vhd
               ct00161.vhd
               ct00162.vhd
               ct00163.vhd
               ct00164.vhd
               ct00165.vhd
               ct00166.vhd
               ct00167.vhd
               ct00168.vhd
               ct00169.vhd
               ct00170.vhd
               ct00171.vhd
               ct00172.vhd
               ct00173.vhd
               ct00174.vhd
               ct00175.vhd
               ct00176.vhd
               ct00177.vhd
               ct00178.vhd
               ct00179.vhd
               ct00180.vhd
               ct00181.vhd
               ct00182.vhd
               ct00183.vhd
               ct00184.vhd
               ct00185.vhd
               ct00186.vhd
               ct00187.vhd
               ct00188.vhd
               ct00189.vhd
               ct00190.vhd
               ct00635.vhd
               ct00636.vhd
               ct00639.vhd
               ct00640.vhd

    Objective: [2] Verify that one or more waveform elements may appear on the 
                   right hand side of a signal assignment statement.   
    Test(s)  : ct00071.vhd
               ct00072.vhd
               ct00073.vhd
               ct00074.vhd
               ct00075.vhd
               ct00076.vhd
               ct00077.vhd
               ct00078.vhd
               ct00079.vhd
               ct00080.vhd
               ct00081.vhd
               ct00082.vhd
               ct00083.vhd
               ct00084.vhd
               ct00085.vhd
               ct00086.vhd
               ct00087.vhd
               ct00088.vhd
               ct00089.vhd
               ct00090.vhd
               ct00091.vhd
               ct00092.vhd
               ct00093.vhd
               ct00094.vhd
               ct00095.vhd
               ct00096.vhd
               ct00097.vhd
               ct00098.vhd
               ct00099.vhd
               ct00100.vhd
               ct00101.vhd
               ct00102.vhd
               ct00103.vhd
               ct00104.vhd
               ct00105.vhd
               ct00106.vhd
               ct00107.vhd
               ct00108.vhd
               ct00109.vhd
               ct00110.vhd
               ct00111.vhd
               ct00112.vhd
               ct00113.vhd
               ct00114.vhd
               ct00115.vhd
               ct00116.vhd
               ct00117.vhd
               ct00118.vhd
               ct00119.vhd
               ct00120.vhd
               ct00121.vhd
               ct00122.vhd
               ct00123.vhd
               ct00124.vhd
               ct00125.vhd
               ct00126.vhd
               ct00127.vhd
               ct00128.vhd
               ct00129.vhd
               ct00130.vhd
               ct00131.vhd
               ct00132.vhd
               ct00133.vhd
               ct00134.vhd
               ct00135.vhd
               ct00136.vhd
               ct00137.vhd
               ct00138.vhd
               ct00139.vhd
               ct00140.vhd
               ct00141.vhd
               ct00142.vhd
               ct00143.vhd
               ct00144.vhd
               ct00145.vhd
               ct00146.vhd
               ct00147.vhd
               ct00148.vhd
               ct00149.vhd
               ct00150.vhd
               ct00151.vhd
               ct00152.vhd
               ct00153.vhd
               ct00154.vhd
               ct00155.vhd
               ct00156.vhd
               ct00157.vhd
               ct00158.vhd
               ct00159.vhd
               ct00160.vhd
               ct00161.vhd
               ct00162.vhd
               ct00163.vhd
               ct00164.vhd
               ct00165.vhd
               ct00166.vhd
               ct00167.vhd
               ct00168.vhd
               ct00169.vhd
               ct00170.vhd
               ct00171.vhd
               ct00172.vhd
               ct00173.vhd
               ct00174.vhd
               ct00175.vhd
               ct00176.vhd
               ct00177.vhd
               ct00178.vhd
               ct00179.vhd
               ct00180.vhd
               ct00181.vhd
               ct00182.vhd
               ct00183.vhd
               ct00184.vhd
               ct00185.vhd
               ct00186.vhd
               ct00187.vhd
               ct00188.vhd
               ct00189.vhd
               ct00190.vhd
               ct00633.vhd
               ct00634.vhd
               ct00635.vhd
               ct00636.vhd
               ct00637.vhd
               ct00638.vhd
               ct00639.vhd
               ct00640.vhd

    Objective: [3] Verify that if the keyword "transport" is present, then the 
                   delay associated with the first waveform element is construed
                   as transport delay.   
    Test(s)  : ct00071.vhd
               ct00072.vhd
               ct00073.vhd
               ct00074.vhd
               ct00075.vhd
               ct00076.vhd
               ct00077.vhd
               ct00078.vhd
               ct00079.vhd
               ct00080.vhd
               ct00081.vhd
               ct00082.vhd
               ct00083.vhd
               ct00084.vhd
               ct00085.vhd
               ct00086.vhd
               ct00087.vhd
               ct00088.vhd
               ct00089.vhd
               ct00090.vhd
               ct00091.vhd
               ct00092.vhd
               ct00093.vhd
               ct00094.vhd
               ct00095.vhd
               ct00096.vhd
               ct00097.vhd
               ct00098.vhd
               ct00099.vhd
               ct00100.vhd
               ct00101.vhd
               ct00102.vhd
               ct00103.vhd
               ct00104.vhd
               ct00105.vhd
               ct00106.vhd
               ct00107.vhd
               ct00108.vhd
               ct00109.vhd
               ct00110.vhd
               ct00111.vhd
               ct00112.vhd
               ct00113.vhd
               ct00114.vhd
               ct00115.vhd
               ct00116.vhd
               ct00117.vhd
               ct00118.vhd
               ct00119.vhd
               ct00120.vhd
               ct00121.vhd
               ct00122.vhd
               ct00123.vhd
               ct00124.vhd
               ct00125.vhd
               ct00126.vhd
               ct00127.vhd
               ct00128.vhd
               ct00129.vhd
               ct00130.vhd
               ct00633.vhd
               ct00634.vhd
               ct00637.vhd
               ct00638.vhd

    Objective: [4] Verify that if the keyword "transport" is not present, then 
                   the delay associated with the first waveform element is 
                   construed as inertial delay.   
    Test(s)  : ct00131.vhd
               ct00132.vhd
               ct00133.vhd
               ct00134.vhd
               ct00135.vhd
               ct00136.vhd
               ct00137.vhd
               ct00138.vhd
               ct00139.vhd
               ct00140.vhd
               ct00141.vhd
               ct00142.vhd
               ct00143.vhd
               ct00144.vhd
               ct00145.vhd
               ct00146.vhd
               ct00147.vhd
               ct00148.vhd
               ct00149.vhd
               ct00150.vhd
               ct00151.vhd
               ct00152.vhd
               ct00153.vhd
               ct00154.vhd
               ct00155.vhd
               ct00156.vhd
               ct00157.vhd
               ct00158.vhd
               ct00159.vhd
               ct00160.vhd
               ct00161.vhd
               ct00162.vhd
               ct00163.vhd
               ct00164.vhd
               ct00165.vhd
               ct00166.vhd
               ct00167.vhd
               ct00168.vhd
               ct00169.vhd
               ct00170.vhd
               ct00171.vhd
               ct00172.vhd
               ct00173.vhd
               ct00174.vhd
               ct00175.vhd
               ct00176.vhd
               ct00177.vhd
               ct00178.vhd
               ct00179.vhd
               ct00180.vhd
               ct00181.vhd
               ct00182.vhd
               ct00183.vhd
               ct00184.vhd
               ct00185.vhd
               ct00186.vhd
               ct00187.vhd
               ct00188.vhd
               ct00189.vhd
               ct00190.vhd
               ct00635.vhd
               ct00636.vhd
               ct00639.vhd
               ct00640.vhd
 
    Objective: [5] Verify that a name on the left hand side may be a simple 
                   name, an indexed name, a slice name, a selected name, and the
                   latter three again within a prefix which is an indexed name 
                   or selected name. 
    Test(s)  : ct00071.vhd
               ct00072.vhd
               ct00073.vhd
               ct00074.vhd
               ct00075.vhd
               ct00076.vhd
               ct00077.vhd
               ct00078.vhd
               ct00079.vhd
               ct00080.vhd
               ct00081.vhd
               ct00082.vhd
               ct00083.vhd
               ct00084.vhd
               ct00085.vhd
               ct00086.vhd
               ct00087.vhd
               ct00088.vhd
               ct00089.vhd
               ct00090.vhd
               ct00091.vhd
               ct00092.vhd
               ct00093.vhd
               ct00094.vhd
               ct00095.vhd
               ct00096.vhd
               ct00097.vhd
               ct00098.vhd
               ct00099.vhd
               ct00100.vhd
               ct00101.vhd
               ct00102.vhd
               ct00103.vhd
               ct00104.vhd
               ct00105.vhd
               ct00106.vhd
               ct00107.vhd
               ct00108.vhd
               ct00109.vhd
               ct00110.vhd
               ct00111.vhd
               ct00112.vhd
               ct00113.vhd
               ct00114.vhd
               ct00115.vhd
               ct00116.vhd
               ct00117.vhd
               ct00118.vhd
               ct00119.vhd
               ct00120.vhd
               ct00121.vhd
               ct00122.vhd
               ct00123.vhd
               ct00124.vhd
               ct00125.vhd
               ct00126.vhd
               ct00127.vhd
               ct00128.vhd
               ct00129.vhd
               ct00130.vhd
               ct00131.vhd
               ct00132.vhd
               ct00133.vhd
               ct00134.vhd
               ct00135.vhd
               ct00136.vhd
               ct00137.vhd
               ct00138.vhd
               ct00139.vhd
               ct00140.vhd
               ct00141.vhd
               ct00142.vhd
               ct00143.vhd
               ct00144.vhd
               ct00145.vhd
               ct00146.vhd
               ct00147.vhd
               ct00148.vhd
               ct00149.vhd
               ct00150.vhd
               ct00151.vhd
               ct00152.vhd
               ct00153.vhd
               ct00154.vhd
               ct00155.vhd
               ct00156.vhd
               ct00157.vhd
               ct00158.vhd
               ct00159.vhd
               ct00160.vhd
               ct00161.vhd
               ct00162.vhd
               ct00163.vhd
               ct00164.vhd
               ct00165.vhd
               ct00166.vhd
               ct00167.vhd
               ct00168.vhd
               ct00169.vhd
               ct00170.vhd
               ct00171.vhd
               ct00172.vhd
               ct00173.vhd
               ct00174.vhd
               ct00175.vhd
               ct00176.vhd
               ct00177.vhd
               ct00178.vhd
               ct00179.vhd
               ct00180.vhd
               ct00181.vhd
               ct00182.vhd
               ct00183.vhd
               ct00184.vhd
               ct00185.vhd
               ct00186.vhd
               ct00187.vhd
               ct00188.vhd
               ct00189.vhd
               ct00190.vhd
 
    Objective: [6] Verify that an aggregate may appear on the left hand side of 
                   a signal assignment statement. 
    Test(s)  : ct00633.vhd
               ct00634.vhd
               ct00635.vhd
               ct00636.vhd
               ct00637.vhd
               ct00638.vhd
               ct00639.vhd
               ct00640.vhd

 
8.3.1  UPDATING A PROJECTED OUTPUT WAVEFORM 
 
    Objective: [1] Verify that when the time expression is omitted in a waveform
                   element, an implicit "after 0ns" is assumed.   
    Test(s)  : ct00191.vhd
               ct00192.vhd
               ct00193.vhd
               ct00194.vhd
               ct00195.vhd
               ct00196.vhd
 
    Objective: [3] Verify the algorithm for updating a projected output waveform
                   if the initial delay is considered to be transport delay (See
                   VHDL LRM 8.3.1). 
    Test(s)  : ct00071.vhd
               ct00072.vhd
               ct00073.vhd
               ct00074.vhd
               ct00075.vhd
               ct00076.vhd
               ct00077.vhd
               ct00078.vhd
               ct00079.vhd
               ct00080.vhd
               ct00081.vhd
               ct00082.vhd
               ct00083.vhd
               ct00084.vhd
               ct00085.vhd
               ct00086.vhd
               ct00087.vhd
               ct00088.vhd
               ct00089.vhd
               ct00090.vhd
               ct00091.vhd
               ct00092.vhd
               ct00093.vhd
               ct00094.vhd
               ct00095.vhd
               ct00096.vhd
               ct00097.vhd
               ct00098.vhd
               ct00099.vhd
               ct00100.vhd
               ct00101.vhd
               ct00102.vhd
               ct00103.vhd
               ct00104.vhd
               ct00105.vhd
               ct00106.vhd
               ct00107.vhd
               ct00108.vhd
               ct00109.vhd
               ct00110.vhd
               ct00111.vhd
               ct00112.vhd
               ct00113.vhd
               ct00114.vhd
               ct00115.vhd
               ct00116.vhd
               ct00117.vhd
               ct00118.vhd
               ct00119.vhd
               ct00120.vhd
               ct00121.vhd
               ct00122.vhd
               ct00123.vhd
               ct00124.vhd
               ct00125.vhd
               ct00126.vhd
               ct00127.vhd
               ct00128.vhd
               ct00129.vhd
               ct00130.vhd
               ct00633.vhd
               ct00634.vhd
               ct00637.vhd
               ct00638.vhd
 
    Objective: [4] Verify the algorithm for updating a projected output waveform
                   if the initial delay is considered to be inertial delay (See 
                   VHDL LRM 8.3.1). 
    Test(s)  : ct00131.vhd
               ct00132.vhd
               ct00133.vhd
               ct00134.vhd
               ct00135.vhd
               ct00136.vhd
               ct00137.vhd
               ct00138.vhd
               ct00139.vhd
               ct00140.vhd
               ct00141.vhd
               ct00142.vhd
               ct00143.vhd
               ct00144.vhd
               ct00145.vhd
               ct00146.vhd
               ct00147.vhd
               ct00148.vhd
               ct00149.vhd
               ct00150.vhd
               ct00151.vhd
               ct00152.vhd
               ct00153.vhd
               ct00154.vhd
               ct00155.vhd
               ct00156.vhd
               ct00157.vhd
               ct00158.vhd
               ct00159.vhd
               ct00160.vhd
               ct00161.vhd
               ct00162.vhd
               ct00163.vhd
               ct00164.vhd
               ct00165.vhd
               ct00166.vhd
               ct00167.vhd
               ct00168.vhd
               ct00169.vhd
               ct00170.vhd
               ct00171.vhd
               ct00172.vhd
               ct00173.vhd
               ct00174.vhd
               ct00175.vhd
               ct00176.vhd
               ct00177.vhd
               ct00178.vhd
               ct00179.vhd
               ct00180.vhd
               ct00181.vhd
               ct00182.vhd
               ct00183.vhd
               ct00184.vhd
               ct00185.vhd
               ct00186.vhd
               ct00187.vhd
               ct00188.vhd
               ct00189.vhd
               ct00190.vhd
               ct00635.vhd
               ct00636.vhd
               ct00639.vhd
               ct00640.vhd
 
    Objective: [6] Verify that a right hand side value expression of type 
                   universal integer or universal real is implicitly converted 
                   to the left hand side type.   
    Test(s)  : ct00193.vhd
               ct00194.vhd
               ct00195.vhd
               ct00196.vhd

 
8.4  VARIABLE ASSIGNMENT STATEMENT 
 
    Objective: [1] Verify that the target of a variable assignment statement may
                   be either a name or an aggregate.   
    Test(s)  : ct00030.vhd
               ct00031.vhd
               ct00032.vhd
               ct00033.vhd
               ct00034.vhd
               ct00035.vhd
               ct00036.vhd
               ct00037.vhd
               ct00041.vhd
               ct00042.vhd
               ct00043.vhd
               ct00044.vhd
               ct00045.vhd
               ct00046.vhd
 
    Objective: [2] Verify that an implicit subtype conversion occurs when the 
                   target is an array variable.   
    Test(s)  : ct00047.vhd
               ct00048.vhd
 
    Objective: [3] Verify that a name on the left hand side may be a simple 
                   name, an indexed name, a slice name, a selected name, and the
                   latter three again with a prefix which is a function call, 
                   indexed name or selected name. 
    Test(s)  : ct00030.vhd
               ct00031.vhd
               ct00032.vhd
               ct00033.vhd
               ct00034.vhd
               ct00035.vhd
               ct00036.vhd
               ct00037.vhd
               ct00041.vhd
               ct00042.vhd
               ct00043.vhd
               ct00044.vhd
               ct00045.vhd
               ct00046.vhd
 
    Objective: [4] Verify that a right hand side value expression of type 
                   universal integer or universal real is implicitly converted 
                   to the left hand side type.   
    Test(s)  : ct00049.vhd
 
 
8.4.1  ARRAY VARIABLE ASSIGNMENTS 
 
    Objective: [1] Verify that the subtype of an array target need not match its
                   right hand side value. 
    Test(s)  : ct00047.vhd
               ct00048.vhd
 
 
8.5  PROCEDURE CALL STATEMENT 
 
    Objective: [1] Verify that the actual parameter part of a procedure call 
                   statement is optional.   
    Test(s)  : ct00522.vhd
 
 
8.6  IF STATEMENT 
 
    Objective: [1] Verify that the else clause of the if statement is optional. 
    Test(s)  : ct00050.vhd
                    
    Objective: [2] Verify that one or more elsif clauses may be present in an if
                   statement.   
    Test(s)  : ct00051.vhd
 
 
8.7  CASE STATEMENT 
 
    Objective: [1] Verify that one or more case alternatives may be present in a
                   case statement.   
    Test(s)  : ct00052.vhd
 
    Objective: [2] Verify that several choices may appear in a case statement 
                   alternative.   
    Test(s)  : ct00054.vhd
 
    Objective: [3] Verify that choices in a case statement where the expression 
                   is of a locally static subtype need not belong to that 
                   subtype. 
    Test(s)  : ct00055.vhd

    Objective: [4] Verify that the others choice may be the only choice. 
    Test(s)  : ct00052.vhd
 
    Objective: [5] Verify that the case expression may be a complex expression. 
    Test(s)  : ct00054.vhd
 
    Objective: [6] Verify that the following discrete types may be the type of a
                   case expression:  user defined enumeration type, predefined 
                   types:  character, bit, boolean, integer types and universal 
                   integer. 
    Test(s)  : ct00052.vhd
               ct00053.vhd
 
    Objective: [7] Verify that simple expressions and discrete ranges are 
                   permitted as choices provided they are locally static. 
    Test(s)  : ct00052.vhd
               ct00053.vhd
 
 
8.8  LOOP STATEMENT 
 
    Objective: [1] Verify that a loop label is optional on a loop statement. 
    Test(s)  : ct00056.vhd
                    
    Objective: [2] Verify that a loop statement without an iteration scheme may 
                   be left when a next statement, exit statement or return 
                   statement is executed.   
    Test(s)  : ct00057.vhd
 
    Objective: [3] Verify that the condition of a loop statement with a while 
                   iteration scheme is evaluated before execution of the 
                   sequence of statements.   
    Test(s)  : ct00058.vhd
               ct00063.vhd
 
    Objective: [4] Verify that the discrete range of a loop statement with a for
                   iteration scheme is evaluated before execution of the 
                   sequence of statements.   
    Test(s)  : ct00059.vhd
 
    Objective: [5] Verify that if the discrete range of a loop statement with a 
                   for iteration scheme is null, then none of the corresponding 
                   sequence of statements in the loop body are evaluated.   
    Test(s)  : ct00059.vhd
 
    Objective: [6] Verify that in the absence of a next, exit or return 
                   statement, the sequence of statements associated with a loop 
                   statement which has a for iteration scheme are executed once 
                   for each value in the discrete range.   
    Test(s)  : ct00060.vhd
               ct00061.vhd
 
    Objective: [7] Verify that values assigned to the loop parameter in a loop 
                   statement with a for iteration scheme are assigned in left to
                   right order.   
    Test(s)  : ct00062.vhd
 
    Objective: [8] Verify that the bounds of the discrete range in a loop 
                   statement with a for iteration may be non-static expressions.
    Test(s)  : ct00061.vhd
 
 
8.9  NEXT STATEMENT 
 
    Objective: [1] Verify that a next statement without a loop label applies 
                   only to the innermost loop (labeled or not).   
    Test(s)  : ct00064.vhd
 
    Objective: [2] Verify that a next statement with a loop label applies to the
                   loop with that label.   
    Test(s)  : ct00065.vhd
 
    Objective: [3] Verify that the condition in a next statement is optional. 
    Test(s)  : ct00064.vhd
               ct00065.vhd
 
    Objective: [4] Verify that if the value of the condition is true in a next 
                   statement, then the current iteration of the corresponding 
                   loop is terminated.   
    Test(s)  : ct00064.vhd
               ct00065.vhd
 
 
8.10  EXIT STATEMENT 
 
    Objective: [1] Verify that an exit statement without a loop label applies 
                   only to the innermost loop (labeled or not).   
    Test(s)  : ct00066.vhd
 
    Objective: [2] Verify that an exit statement with a loop label applies to 
                   the loop with that label.   
    Test(s)  : ct00067.vhd
 
    Objective: [3] Verify that the condition in an exit statement is optional. 
    Test(s)  : ct00066.vhd
               ct00067.vhd
 
    Objective: [4] Verify that if the value of the condition is true in an exit 
                   statement, then the corresponding loop is exited.   
    Test(s)  : ct00066.vhd
               ct00067.vhd
 
 
8.11  RETURN STATEMENT 
 
    Objective: [1] Verify that a return statement in a procedure terminates 
                   execution of that procedure.   
    Test(s)  : ct00068.vhd
 
    Objective: [2] Verify that a return statement in a function terminates 
                   execution of that function.   
    Test(s)  : ct00069.vhd
 
    Objective: [3] Verify that the value of the return expression in a function 
                   defines the result returned by the function.   
    Test(s)  : ct00069.vhd
 
    Objective: [4] Verify that multiple return statements may occur in a 
                   subprogram. 
    Test(s)  : ct00068.vhd
               ct00069.vhd
 
    Objective: [5] Verify that a procedure need not have a return statement. 
    Test(s)  : ct00070.vhd
 
 
9.1  BLOCK STATEMENT 
 
    Objective: [1] Verify that the block label is optional at the end of the 
                   block statement.   
    Test(s)  : ct00278.vhd
 
    Objective: [2] Verify that a guard expression is optional after the reserved
                   word block in a block statement.   
    Test(s)  : ct00280.vhd
 
    Objective: [3] Verify that the implicit GUARD signal may be explicitly 
                   referenced within the block statement (e.g.  appear in an 
                   expression, be associated with formal ports of mode "in", 
                   "buffer" and "linkage"). 
    Test(s)  : ct00281.vhd
 
    Objective: [4] Verify that the implicitly declared signal GUARD may be 
                   explicitly passed as an actual signal in a component 
                   instantiation. 
    Test(s)  : ct00281.vhd
 
    Objective: [5] Verify that the generic clause of a block statement is 
                   optional.   
    Test(s)  : ct00285.vhd
 
    Objective: [6] Verify that the port clause of a block statement is optional.
    Test(s)  : ct00301.vhd
 
    Objective: [7] Verify that the generic map aspect of a block statement is 
                   optional when a generic clause is specified.   
    Test(s)  : ct00302.vhd
 
    Objective: [8] Verify that the port map aspect of a block statement is 
                   optional when a port clause is specified.   
    Test(s)  : ct00303.vhd
 
    Objective: [9] Verify that each of the following items may appear in a block
                   declarative part:  subprogram declaration, subprogram body, 
                   type declaration, subtype declaration, constant declaration, 
                   signal declaration, file declaration, alias declaration, 
                   component declaration, attribute declaration, label 
                   declaration, attribute specification, configuration 
                   specification, disconnection specification, use clause.   
    Test(s)  : ct00305.vhd
               ct00313.vhd
 
    Objective: [10] Verify that each of the following concurrent statements may 
                   appear in a block statement part:  block statement, process 
                   statement, assertion statement, concurrent procedure call 
                   statement, signal assignment statement, component 
                   instantiation statement, generate statement.   
    Test(s)  : ct00305.vhd
               ct00313.vhd
 
    Objective: [11] Verify that no block declarative item need appear in a block
                   statement.   
    Test(s)  : ct00304.vhd
 
    Objective: [12] Verify that no concurrent statement need appear in a block 
                   statement.   
    Test(s)  : ct00304.vhd
 
 
9.2  PROCESS STATEMENT 
 
    Objective: [1] Verify that the label is optional on a process statement. 
    Test(s)  : ct00315.vhd
                    
    Objective: [2] Verify that a sensitivity list is optional on a process 
                   statement.   
    Test(s)  : ct00315.vhd
 
    Objective: [3] Verify that any of the following may appear as a process 
                   declarative item:  subprogram declaration, subprogram body, 
                   type declaration, subtype declaration, constant declaration, 
                   variable declaration, file declaration, alias declaration, 
                   attribute declaration, attribute specification, use clause. 
    Test(s)  : ct00316.vhd
                    
    Objective: [4] Verify that no process declarative item need appear in a 
                   process declarative part.   
    Test(s)  : ct00315.vhd
 
    Objective: [5] Verify that any of the following sequential statements may 
                   appear in a process statement part:  wait statement, 
                   assertion statement, signal assignment statement, variable 
                   assignment statement, procedure call statement, if statement,
                   case statement, loop statement, next statement, exit 
                   statement, null statement.   
    Test(s)  : ct00316.vhd
 
    Objective: [6] Verify that no sequential statements need appear in a process
                   statement part.   
    Test(s)  : ct00318.vhd
 
    Objective: [7] Verify that the implicit wait statement for a process with a 
                   sensitivity list occurs as the last sequential statement in 
                   the sequence of statements.   
    Test(s)  : ct00319.vhd
 
    Objective: [8] Verify that after execution of the last sequential statement 
                   in a process statement, execution continues with the first 
                   statement in the sequence of statements.   
    Test(s)  : ct00320.vhd
 
 
9.3  CONCURRENT PROCEDURE CALL 
 
    Objective: [1] Verify that a label is optional on a concurrent procedure 
                   call.   
    Test(s)  : ct00610.vhd
               ct00630.vhd
 
    Objective: [2] Verify that in the absence of signal parameters of mode "in"
                   or "inout", a concurrent procedure call statement is
                   equivalent to the process statement shown in Section 9.3 of
                   the LRM where a wait statement with no sensitivity clause
                   appears at the end of the equivalent process.
    Test(s)  : ct00610.vhd

    Objective: [3] Verify that if actual signals are associated with formal 
                   parameters of mode "in" or "inout", a concurrent procedure 
                   call statement is equivalent to the process statement shown 
                   in Section 9.3 of the LRM where a wait statement with a 
                   sensitivity clause containing the longest static prefix of 
                   each such actual appears at the end of the equivalent 
                   process.   
    Test(s)  : ct00611.vhd
               ct00612.vhd
               ct00613.vhd
               ct00614.vhd
               ct00615.vhd
               ct00616.vhd
               ct00617.vhd
               ct00618.vhd
               ct00619.vhd
               ct00620.vhd
               ct00621.vhd
               ct00622.vhd
               ct00623.vhd
               ct00624.vhd
               ct00625.vhd
               ct00626.vhd
               ct00627.vhd
               ct00628.vhd
               ct00629.vhd
 
 
9.4  CONCURRENT ASSERTION STATEMENT 
 
    Objective: [1] Verify that a label is optional on a concurrent assertion 
                   statement.   
    Test(s)  : ct00321.vhd
 
    Objective: [2] Verify that in the absence of a report expression the default
                   is "Assertion Violation."  
    Test(s)  : ct00321.vhd
 
    Objective: [3] Verify that in the absence of a severity expression the 
                   default is ERROR.   
    Test(s)  : ct00321.vhd
 
    Objective: [4] Verify that both the report expression and the severity 
                   expression are optional.   
    Test(s)  : ct00321.vhd
 
    Objective: [5] Verify that the severity expression may evaluate to any of 
                   the values of the predefined type SEVERITY_LEVEL.   
    Test(s)  : ct00322.vhd
               ct00323.vhd
               ct00324.vhd
               ct00325.vhd
 
    Objective: [6] Verify that the report expression may be a complicated string
                   expression.   
    Test(s)  : ct00326.vhd
 
    Objective: [7] Verify that in the absence of primaries that denote signals 
                   in a concurrent assertion statement, a wait statement with no
                   sensitivity clause appears at the end of the equivalent 
                   process.   
    Test(s)  : ct00327.vhd
 
    Objective: [8] Verify that if primaries that denote signals appear in a 
                   concurrent assertion statement, then a wait statement with a 
                   sensitivity clause containing the longest static prefix of 
                   each such actual appears at the end of the equivalent 
                   process.   
    Test(s)  : ct00328.vhd
 
 
9.5  CONCURRENT SIGNAL ASSIGNMENT STATEMENT 
 
    Objective: [1] Verify that the label is optional on a concurrent signal 
                   assignment statement.   
    Test(s)  : ct00332.vhd
 
    Objective: [2] Verify that when the TRANSPORT option is given, then each 
                   signal assignment statement in the equivalent process 
                   statement has the TRANSPORT option.   
    Test(s)  : ct00336.vhd
               ct00337.vhd
               ct00338.vhd
               ct00339.vhd
               ct00340.vhd
               ct00341.vhd
               ct00342.vhd
               ct00343.vhd
               ct00344.vhd
               ct00345.vhd
               ct00349.vhd
               ct00350.vhd
               ct00351.vhd
               ct00352.vhd
               ct00353.vhd
               ct00354.vhd
               ct00355.vhd
               ct00356.vhd
               ct00357.vhd
               ct00358.vhd
               ct00359.vhd
               ct00360.vhd
               ct00361.vhd
               ct00362.vhd
               ct00363.vhd
               ct00364.vhd
               ct00365.vhd
               ct00366.vhd
               ct00367.vhd
               ct00368.vhd
               ct00369.vhd
               ct00370.vhd
               ct00371.vhd
               ct00372.vhd
               ct00373.vhd
               ct00374.vhd
               ct00375.vhd
               ct00376.vhd
               ct00377.vhd
               ct00378.vhd
 
    Objective: [3] Verify that when the TRANSPORT option is not given, then no 
                   signal assignment statement in the equivalent process 
                   statement has the TRANSPORT option.   
    Test(s)  : ct00381.vhd
               ct00382.vhd
               ct00383.vhd
               ct00384.vhd
               ct00385.vhd
               ct00386.vhd
               ct00387.vhd
               ct00388.vhd
               ct00389.vhd
               ct00390.vhd
               ct00391.vhd
               ct00392.vhd
               ct00393.vhd
               ct00394.vhd
               ct00395.vhd
               ct00396.vhd
               ct00397.vhd
               ct00398.vhd
               ct00399.vhd
               ct00400.vhd
               ct00401.vhd
               ct00402.vhd
               ct00403.vhd
               ct00404.vhd
               ct00405.vhd
               ct00406.vhd
               ct00407.vhd
               ct00408.vhd
               ct00409.vhd
               ct00410.vhd
               ct00411.vhd
               ct00412.vhd
               ct00413.vhd
               ct00414.vhd
               ct00415.vhd
               ct00416.vhd
               ct00417.vhd
               ct00418.vhd
               ct00419.vhd
               ct00420.vhd
 
    Objective: [4] Verify that the signal GUARD used in a guarded assignment may
                   either be one of the implicitly declared GUARD signals 
                   associated with block statements that have guard expressions,
                   or it may be an explicitly declared signal of type BOOLEAN 
                   that is visible at the point of the concurrent signal 
                   assignment statement.   
    Test(s)  : ct00433.vhd
               ct00436.vhd
               ct00445.vhd

    Objective: [5] Verify that when the option GUARDED is specified, the signal 
                   transform is executed when a signal GUARD changes from FALSE 
                   to TRUE.   
    Test(s)  : ct00433.vhd
               ct00436.vhd

    Objective: [7] Verify that when the option GUARDED is specified and the 
                   target is a guarded target, disconnection statements are 
                   executed when the guard is false and an event has occurred on
                   one of its inputs.   
    Test(s)  : ct00445.vhd
 
    Objective: [8] Verify that in the absence of primaries (in expressions other
                   than time expressions) that denote signals in a concurrent 
                   signal assignment statement, a wait statement with no 
                   sensitivity clause (except possibly for the signal guard) 
                   appears at the end of the equivalent process.   
    Test(s)  : ct00447.vhd
               ct00448.vhd
 
    Objective: [9] Verify that if primaries (in expressions other than time 
                   expressions) that denote signals appear in a concurrent 
                   signal assignment statement, then a wait statement with a 
                   sensitivity clause containing the longest static prefix of 
                   each such actual appears at the end of the equivalent 
                   process.   
    Test(s)  : ct00433.vhd
               ct00436.vhd
               ct00445.vhd
 
 
9.5.1  CONDITIONAL SIGNAL ASSIGNMENT 
 
    Objective: [1] Verify that the conditional waveforms may consist of just a 
                   single waveform.   
    Test(s)  : ct00337.vhd
               ct00339.vhd
               ct00341.vhd
               ct00343.vhd
               ct00345.vhd
               ct00350.vhd
               ct00352.vhd
               ct00354.vhd
               ct00356.vhd
               ct00358.vhd
               ct00360.vhd
               ct00362.vhd
               ct00364.vhd
               ct00366.vhd
               ct00368.vhd
               ct00370.vhd
               ct00372.vhd
               ct00374.vhd
               ct00376.vhd
               ct00378.vhd
               ct00382.vhd
               ct00384.vhd
               ct00386.vhd
               ct00388.vhd
               ct00390.vhd
               ct00392.vhd
               ct00394.vhd
               ct00396.vhd
               ct00398.vhd
               ct00400.vhd
               ct00402.vhd
               ct00404.vhd
               ct00406.vhd
               ct00408.vhd
               ct00410.vhd
               ct00412.vhd
               ct00414.vhd
               ct00416.vhd
               ct00418.vhd
               ct00420.vhd
 
    Objective: [2] Verify that many conditional waveforms may appear in a 
                   conditional signal assignment statement.   
    Test(s)  : ct00337.vhd
               ct00339.vhd
               ct00341.vhd
               ct00343.vhd
               ct00345.vhd
               ct00350.vhd
               ct00352.vhd
               ct00354.vhd
               ct00356.vhd
               ct00358.vhd
               ct00360.vhd
               ct00362.vhd
               ct00364.vhd
               ct00366.vhd
               ct00368.vhd
               ct00370.vhd
               ct00372.vhd
               ct00374.vhd
               ct00376.vhd
               ct00378.vhd
               ct00382.vhd
               ct00384.vhd
               ct00386.vhd
               ct00388.vhd
               ct00390.vhd
               ct00392.vhd
               ct00394.vhd
               ct00396.vhd
               ct00398.vhd
               ct00400.vhd
               ct00402.vhd
               ct00404.vhd
               ct00406.vhd
               ct00408.vhd
               ct00410.vhd
               ct00412.vhd
               ct00414.vhd
               ct00416.vhd
               ct00418.vhd
               ct00420.vhd
 
 
9.5.2  SELECTED SIGNAL ASSIGNMENT 
 
    Objective: [1] Verify that a selected signal assignment may have one or more
                   selected waveforms.   
    Test(s)  : ct00336.vhd
               ct00338.vhd
               ct00340.vhd
               ct00342.vhd
               ct00344.vhd
               ct00349.vhd
               ct00351.vhd
               ct00353.vhd
               ct00355.vhd
               ct00357.vhd
               ct00359.vhd
               ct00361.vhd
               ct00363.vhd
               ct00365.vhd
               ct00367.vhd
               ct00369.vhd
               ct00371.vhd
               ct00373.vhd
               ct00375.vhd
               ct00377.vhd
               ct00381.vhd
               ct00383.vhd
               ct00385.vhd
               ct00387.vhd
               ct00389.vhd
               ct00391.vhd
               ct00393.vhd
               ct00395.vhd
               ct00397.vhd
               ct00399.vhd
               ct00401.vhd
               ct00403.vhd
               ct00405.vhd
               ct00407.vhd
               ct00409.vhd
               ct00411.vhd
               ct00413.vhd
               ct00415.vhd
               ct00417.vhd
               ct00419.vhd
 
 
9.6  COMPONENT INSTANTIATION STATEMENT 
 
    Objective: [1] Verify that the generic and port map aspects in a component 
                   instantiation statement are optional.   
    Test(s)  : ct00331.vhd
 
    Objective: [2] Verify that a component may be instantiated several times in 
                   a block statement. 
    Test(s)  : ct00330.vhd
 
    Objective: [3] Verify that a component need not be instantiated if a 
                   component declaration is given. 
    Test(s)  : ct00329.vhd
 
 
9.7  GENERATE STATEMENT 
 
    Objective: [1] Verify that each of the following concurrent statements may 
                   appear within a generate statement:  block statement, process
                   statement, assertion statement, concurrent procedure call 
                   statement, signal assignment statement, component 
                   instantiation statement, generate statement.   
    Test(s)  : ct00449.vhd
               ct00451.vhd
 
    Objective: [2] Verify that no concurrent statement need appear in a generate
                   statement.   
    Test(s)  : ct00452.vhd
 
    Objective: [3] Verify that labels appearing on a concurrent or sequential 
                   statement may be either a label simple name or a label index 
                   name.   
    Test(s)  : ct00449.vhd
 
    Objective: [4] Verify that a generation scheme may be either a for 
                   generation scheme or an if condition generation scheme.   
    Test(s)  : ct00449.vhd
               ct00451.vhd
               ct00452.vhd
               ct00458.vhd

 
    Objective: [5] Verify that the following discrete types may be the type of 
                   the range in a generate parameter specification:  user 
                   defined enumeration types, predefined types:  character, bit,
                   boolean, and integer types. 
    Test(s)  : ct00465.vhd
               ct00466.vhd
 
    Objective: [6] Verify that a locally static discrete range is permitted in a
                   generate parameter specification. 
    Test(s)  : ct00465.vhd
               ct00467.vhd
 
    Objective: [7] Verify that a globally static discrete range is permitted in 
                   a generate parameter specification. 
    Test(s)  : ct00466.vhd
               ct00468.vhd
 
    Objective: [8] Verify that a locally static condition is permitted in a 
                   generate condition. 
    Test(s)  : ct00449.vhd
               ct00451.vhd
               ct00452.vhd
 
    Objective: [9] Verify that a globally static condition is permitted in a 
                   generate condition. 
    Test(s)  : ct00449.vhd
               ct00458.vhd
 
    Objective: [10] Verify that a null discrete range is permitted in a generate
                   parameter specification. 
    Test(s)  : ct00467.vhd
               ct00468.vhd
 
 
10.3  VISIBILITY 
 
    Objective: [1] Verify that entities declared within a declarative region are
                   directly visible from the end of the declaration or after the
                   keyword IS in design unit declarations through the end of 
                   that region where not hidden.  As a special case, check for 
                   labels and generate parameters. 
    Test(s)  : ct00519.vhd
               ct00523.vhd
 
    Objective: [2] Verify that entities declared outside a declarative region 
                   that are directly visible at the point of declaration and are
                   not hidden are directly visible within the declarative 
                   region. 
    Test(s)  : ct00519.vhd
               ct00523.vhd
 
    Objective: [3] Verify that when a homograph hides a declaration which would 
                   otherwise be visible by selection the declaration is still 
                   visible by selection. 
    Test(s)  : ct00524.vhd
 
    Objective: [4] Verify that entities for which a selected name is possible 
                   may be referenced by selected names where they are also 
                   directly visible. 
    Test(s)  : ct00525.vhd
 
    Objective: [5] Verify that names denoting entities declared in a package 
                   declaration are permitted, within the scope of the package 
                   and following the entity declaration or the keyword IS in 
                   design unit declarations, as the select suffix of a selected 
                   name whose select prefix denotes the package. 
    Test(s)  : ct00524.vhd
               ct00525.vhd
               ct00526.vhd
 
    Objective: [6] Verify that names denoting elements of records are permitted,
                   within the scope of the record type and following the entity 
                   declaration, as the select suffix of a selected name whose 
                   select prefix is the name of an object of the record type or 
                   as a named element in an aggregate of an object of the record
                   type. 
    Test(s)  : ct00536.vhd
 
    Objective: [7] Verify that names denoting subprogram formal parameters are 
                   permitted, within the scope of the subprogram and following 
                   the parameter declaration, as the formal designators in a 
                   named parameter association list in a call to the subprogram.
    Test(s)  : ct00538.vhd
 
    Objective: [8] Verify that names denoting a local port or generic declared 
                   in a component declaration are permitted, within the scope of
                   the component following the port or generic declaration, as 
                   the formal designator in the formal part of a corresponding 
                   port or generic named association element in a corresponding 
                   component instantiation statement. 
    Test(s)  : ct00539.vhd
 
    Objective: [9] Verify that names denoting a formal port or generic declared 
                   in an entity declaration are permitted, within the scope of 
                   the design entity following the port or generic declaration, 
                   as the formal designator in the formal part of a 
                   corresponding port or generic named association element in a 
                   corresponding binding indication. 
    Test(s)  : ct00539.vhd
 
    Objective: [10] Verify that a predefined attribute single name is permitted 
                   anywhere following the delimiter ' in an attribute name whose
                   prefix belongs to the given range of definition. 
    Test(s)  : ct00543.vhd
 
    Objective: [11] Verify that library names denoting architectural bodies in 
                   the design library are permitted inside any corresponding 
                   configuration body declaration or as the body indication in a
                   body aspect inside any following design unit. 
    Test(s)  : ct00546.vhd
 
    Objective: [13] Verify that library names denoting entity declarations in
                   the design library are permitted as the entity indication
                   in an entity aspect in any following design unit. 
    Test(s)  : ct00546.vhd
 
    Objective: [14] Verify that the scope of a library unit contained within a 
                   design library is extended with the scope of the logical 
                   library corresponding to that design library.  (thus packages
                   do not need use clauses to be used in an expanded name) 
    Test(s)  : ct00573.vhd
 
 
10.4  USE CLAUSES 
 
    Objective: [1] Verify that it is not an error to declare an entity that has 
                   the same name as the name of an entity declared in a use'd 
                   package. 
    Test(s)  : ct00574.vhd
               ct00575.vhd
               ct00576.vhd
               ct00577.vhd
 
    Objective: [2] Verify that package STANDARD is implicitly use'd in every 
                   design unit. 
    Test(s)  : ct00578.vhd
 
    Objective: [3] Verify that us'ing a package makes entities declared in the 
                   use'd package directly visible in the us'ing package.  That 
                   is, entities declared within the use'd package may be 
                   referenced by simple names in the us'ing design unit. 
    Test(s)  : ct00579.vhd
 
    Objective: [4] Verify that a package may be use'd more than once in a design
                   unit. 
    Test(s)  : ct00577.vhd
 
 
10.5  THE CONTEXT OF OVERLOAD RESOLUTION 
 
    Objective: [1] Verify that any of the five rule forms listed in the LRM may 
                   be sufficient to disambiguate an overloaded reference. 
    Test(s)  : ct00580.vhd
               ct00581.vhd
               ct00597.vhd
 
 
11.1  DESIGN UNITS 
 
    Objective: [1] Verify that the following may appear together or separately 
                   in a design file:  entity declaration, configuration 
                   declaration, package declaration, architecture body, package 
                   body.   
    Test(s)  : ct00578.vhd
               ct00601.vhd
               ct00603.vhd
               ct00604.vhd
               ct00605.vhd
               ct00606.vhd
               ct00607.vhd
 
    Objective: [2] Verify that a context clause may appear before each of the 
                   following in a design file:  entity declaration, 
                   configuration declaration, package declaration, architecture 
                   body, package body.   
    Test(s)  : ct00608.vhd
 
 
11.2  DESIGN LIBRARIES 
 
    Objective: [1] Verify that the implicit library clause "library STD, WORK" 
                   is present by referencing these two libraries in expanded 
                   names.   
    Test(s)  : ct00609.vhd
 
 
11.3  CONTEXT CLAUSES 
 
    Objective: [1] Verify that a context clause may be null.   
    Test(s)  : ct00609.vhd
 
 
12.2  ELABORATION OF A BLOCK HEADER 
 
    Objective: [1] Verify that the generic clause and generic map clause are 
                   elaborated before the port clause.   
    Test(s)  : ct00379.vhd
 
 
12.3  ELABORATION OF A DECLARATIVE PART 
 
    Objective: [1] Verify that declarative items in a declarative part are 
                   elaborated in the order given. 
    Test(s)  : ct00380.vhd
 
 
12.3.1.4  OBJECT DECLARATIONS 
 
    Objective: [1] Verify that, like an assignment statement, an implicit 
                   subtype conversion is performed for an array object unless 
                   the object is a constant whose subtype is an unconstrained 
                   array type.   
    Test(s)  : ct00471.vhd
 
 
12.4.1  BLOCK STATEMENTS 
 
    Objective: [1] Verify that a block declarative part is elaborated after the 
                   block header.   
    Test(s)  : ct00421.vhd
 
    Objective: [2] Verify that the block statement part is elaborated after the 
                   block declarative part.   
    Test(s)  : ct00421.vhd
 
 
12.4.2  GENERATE STATEMENTS 
 
    Objective: [1] Verify that for a generate statement with a "for" generation 
                   scheme, one copy of the enclosed text is generated for each 
                   value in the discrete range given in the generation scheme. 
    Test(s)  : ct00470.vhd
 
    Objective: [2] Verify that occurrences of the generate parameter in the body
                   of a generate statement with a "for" generation scheme are 
                   replaced in each copy by the corresponding value of the 
                   generate parameter.   
    Test(s)  : ct00470.vhd
 
    Objective: [3] Verify that for a generate statement with an "if" generation 
                   scheme one copy of the enclosed text is generated if the 
                   expression evaluates to true. 
    Test(s)  : ct00470.vhd
 
 
12.5  DYNAMIC ELABORATION 
 
    Objective: [1] Verify that actual parameters are associated with formal 
                   parameters before the declarative part of a subprogram body 
                   is elaborated.   
    Test(s)  : ct00422.vhd
 
 
13.1  CHARACTER SET 
 
    Objective: [1] Verify that the basic character set is accepted outside of 
                   string literals and comments. 
    Test(s)  : ct00423.vhd
 
 
13.2  LEXICAL ELEMENTS, SEPARATORS, AND DELIMITERS 
 
    Objective: [1] Verify that delimiters (simple and compound) delimit any two 
                   adjacent lexical elements. 
    Test(s)  : ct00442.vhd
 
    Objective: [2] Verify that separators are required only when interpretation 
                   as a single lexical element is otherwise possible. 
    Test(s)  : ct00442.vhd
 
 
13.3  IDENTIFIERS 
 
    Objective: [1] Verify that upper and lower case letters are equivalent in 
                   identifiers (including reserved words). 
    Test(s)  : ct00424.vhd
 
    Objective: [2] Verify that the maximum input line length is 132. 
    Test(s)  : ct00424.vhd
 
    Objective: [3] Verify that variable identifiers can be as long as the 
                   maximum input line length permitted and that all characters 
                   are significant. 
    Test(s)  : ct00424.vhd
 
 
13.4.1  DECIMAL LITERALS 
 
    Objective: [1] Verify that both upper case and lower case E may be used to 
                   indicate exponent in both integer and real literals. 
    Test(s)  : ct00425.vhd
 
    Objective: [2] Verify that an underscore may be inserted between adjacent 
                   digits in any part of an abstract literal without affecting 
                   the value of the abstract literal. 
    Test(s)  : ct00425.vhd
 
    Objective: [3] Verify that leading zeros in integral parts of integer 
                   literals are ignored. 
    Test(s)  : ct00425.vhd
 
    Objective: [4] Verify that integer literals can be as long as the maximum 
                   input line length and still yield representable values. 
    Test(s)  : ct00425.vhd
 
    Objective: [5] Verify that leading zeros in integral parts and trailing 
                   zeros in fractional parts of real literals are ignored. 
    Test(s)  : ct00425.vhd
 
    Objective: [6] Verify that real literals can be as long as the maximum input
                   line length and still yield representable values. 
    Test(s)  : ct00425.vhd
 
    Objective: [7] Verify that a zero exponent is allowed for an integer 
                   literal. 
    Test(s)  : ct00425.vhd
 
 
13.4.2  BASED LITERALS 
 
    Objective: [1] Verify that both uppercase and lowercase letters A B C D E F 
                   are allowed as extended digits in based literals (integer and
                   real). 
    Test(s)  : ct00428.vhd
 
    Objective: [2] Verify that based integer literals with bases '2' through 
                   '16' all yield correct values. 
    Test(s)  : ct00428.vhd
 
 
13.5  CHARACTER LITERALS 
 
    Objective: [1] Verify that any graphic character, including a single ', can 
                   be used as the data character in a character literal. 
    Test(s)  : ct00429.vhd
 
 
13.6  STRING LITERALS 
 
    Objective: [1] Verify that all graphic characters, except a single ", are 
                   permitted as data characters in string literals. 
    Test(s)  : ct00430.vhd
 
    Objective: [2] Verify that doubled " can be used as a data character in 
                   string literals. 
    Test(s)  : ct00430.vhd
 
    Objective: [3] Verify that uppercase and lowercase letters are distinct 
                   within a string literal. 
    Test(s)  : ct00430.vhd
 
    Objective: [5] Verify that null strings are permitted. 
    Test(s)  : ct00430.vhd
 
 
13.7  BIT STRING LITERALS 
 
    Objective: [1] Verify that B O and X (and their lowercase counterparts) are 
                   permitted as base specifiers and that they yield the correct 
                   values. 
    Test(s)  : ct00435.vhd
 
    Objective: [2] Verify that both A..F and a..f are equivalent when used as 
                   extended digits in bit string literals with base specifier X.
    Test(s)  : ct00435.vhd
 
    Objective: [3] Verify that an underscore may be inserted between adjacent 
                   digits without affecting the value of the bit string literal.
    Test(s)  : ct00435.vhd
 
 
13.8  COMMENTS 
 
    Objective: [1] Verify that each occurrence of two adjacent hyphens not in a 
                   string literal nor inside a previously begun comment begins a
                   comment. 
    Test(s)  : ct00437.vhd
 
 
13.10  ALLOWABLE REPLACEMENT OF CHARACTERS 
 
    Objective: [1] Verify that the !  :  % are equivalent to the characters they
                   replace. 
    Test(s)  : ct00441.vhd
 
    Objective: [2] Verify that doubled % can be used as a data character in a 
                   string literal when the quotation character string brackets 
                   are replaced by percent characters. 
    Test(s)  : ct00441.vhd
 
 
14.1  PREDEFINED ATTRIBUTES 
 
    Objective: [1] Verify that BASE, LEFT, RIGHT, HIGH, LOW, POS, VAL, SUCC, 
                   PRED, LENGTH, DELAYED, STABLE, QUIET, EVENT, ACTIVE, 
                   LAST_EVENT, LAST_ACTIVE, LAST_VALUE, BEHAVIOR, and STRUCTURE 
                   are not reserved words. 
    Test(s)  : ct00530.vhd
 
    Objective: [2] Verify that the range of T in T'BASE is any type or subtype. 
    Test(s)  : ct00533.vhd
 
    Objective: [3] Verify that the value of T'BASE is correct. 
    Test(s)  : ct00533.vhd
 
    Objective: [4] Verify that the range of T in T'LEFT, T'RIGHT, T'LOW, and 
                   T'HIGH is any scalar or constrained array subtype or any 
                   array object or array value. 
    Test(s)  : ct00534.vhd
 
    Objective: [5] Verify that the value of T'LEFT and T'RIGHT is correct. 
    Test(s)  : ct00534.vhd
 
    Objective: [6] Verify that the value of T'LOW and T'HIGH is correct (special
                   case where T'LOW = T'RIGHT) 
    Test(s)  : ct00534.vhd
 
    Objective: [7] Verify that the range of T in T'POS(X), T'VAL(X), T'SUCC(X), 
                   T'PRED(X), T'LEFTOF(X) and T'RIGHTOF(X) is any discrete or 
                   physical type or subtype. 
    Test(s)  : ct00535.vhd
 
    Objective: [8] Verify that the value of T'POS(X) is correct. 
    Test(s)  : ct00535.vhd
 
    Objective: [9] Verify that the value of T'VAL(X) is correct. 
    Test(s)  : ct00535.vhd
 
    Objective: [10] Verify that T'SUCC(X) and T'PRED(X) give the correct values.
                   In particular, Verify that if S is a subtype of T then 
                   S'SUCC(X) does not give an error if S'HIGH = X but 
                   S'BASE'HIGH /= X, and that S'PRED(X) does not give an error 
                   if S'LOW = X but S'BASE'LOW /= X. 
    Test(s)  : ct00535.vhd
 
    Objective: [11] Verify that T'LEFTOF(X) and T'RIGHTOF(X) give the correct 
                   values.  In particular, Verify that if S is a subtype of T 
                   then S'LEFTOF(X) does not give an error if S'LEFT = X but 
                   S'BASE'LEFT /= X, and that S'RIGHTOF(X) does not give an 
                   error if S'RIGHT = X but S'BASE'RIGHT /= X. 
    Test(s)  : ct00535.vhd
 
    Objective: [12] Verify that A in A'LEFT(N), A'RIGHT(N), A'HIGH(N), A'LOW(N),
                   A'RANGE(N), A'REVERSE_RANGE(N) and A'LENGTH(N) can be an 
                   array object, an array value, or a constrained array type or 
                   subtype. 
    Test(s)  : ct00540.vhd
 
    Objective: [13] Verify that if A is not a scalar type or subtype and (N) is 
                   omitted in A'LEFT(N), A'RIGHT(N), A'HIGH(N), or A'LOW(N) the 
                   default is N=1. 
    Test(s)  : ct00534.vhd
 
    Objective: [14] Verify that if (N) is omitted in A'RANGE(N), 
                   A'REVERSE_RANGE(N) or A'LENGTH(N) the default is N=1. 
    Test(s)  : ct00540.vhd
 
    Objective: [15] Verify that the value of B'BEHAVIOR and B'STRUCTURE is 
                   correct. 
    Test(s)  : ct00663.vhd
 
    Objective: [16] Verify that the range of S in S'DELAYED, S'STABLE, S'QUIET, 
                   S'EVENT, S'ACTIVE, S'LAST_EVENT, S'LAST_ACTIVE and 
                   S'LAST_VALUE is any object of class signal and of mode "in", 
                   "buffer", or "inout" denoted by the static signal name S. 
    Test(s)  : ct00542.vhd
 
    Objective: [17] Verify that S'DELAYED(T), S'STABLE(T), and S'QUIET(T) denote
                   signals. 
    Test(s)  : ct00541.vhd
 
    Objective: [18] Verify that the range of B in B'BEHAVIOR and B'STRUCTURE is 
                   any block statement or architectural body. 
    Test(s)  : ct00663.vhd
 
 
14.2  PACKAGE STANDARD 
 
    Objective: [1] Verify that the function NOW returns the correct value. 
    Test(s)  : ct00571.vhd
 
    Objective: [2] Verify that STANDARD is not a reserved word. 
    Test(s)  : ct00571.vhd
 
 
