IMS Logo

IMS Question and Test Interoperability: XML Binding

Version 2.0 Final Specification

Copyright © 2005 IMS Global Learning Consortium, Inc. All Rights Reserved.
The IMS Logo is a registered trademark of IMS/GLC.
Document Name: IMS Question and Test Interoperability XML Binding
Revision: 24 January 2005


Date Issued: 24 January 2005

IPR and Distribution Notices

Recipients of this document are requested to submit, with their comments, notification of any relevant patent claims or other intellectual property rights of which they may be aware that might be infringed by any implementation of the specification set forth in this document, and to provide supporting documentation.

IMS takes no position regarding the validity or scope of any intellectual property or other rights that might be claimed to pertain to the implementation or use of the technology described in this document or the extent to which any license under such rights might or might not be available; neither does it represent that it has made any effort to identify any such rights. Information on IMS's procedures with respect to rights in IMS specifications can be found at the IMS Intellectual Property Rights web page: http://www.imsglobal.org/ipr/imsipr_policyFinal.pdf.

Copyright © 2005 IMS Global Learning Consortium. All Rights Reserved.

Permission is granted to all parties to use excerpts from this document as needed in producing requests for proposals.

Use of this specification to develop products or services is governed by the license with IMS found on the IMS website: http://www.imsglobal.org/license.html.

The limited permissions granted above are perpetual and will not be revoked by IMS or its successors or assigns.

THIS SPECIFICATION IS BEING OFFERED WITHOUT ANY WARRANTY WHATSOEVER, AND IN PARTICULAR, ANY WARRANTY OF NONINFRINGEMENT IS EXPRESSLY DISCLAIMED. ANY USE OF THIS SPECIFICATION SHALL BE MADE ENTIRELY AT THE IMPLEMENTER'S OWN RISK, AND NEITHER THE CONSORTIUM, NOR ANY OF ITS MEMBERS OR SUBMITTERS, SHALL HAVE ANY LIABILITY WHATSOEVER TO ANY IMPLEMENTER OR THIRD PARTY FOR ANY DAMAGES OF ANY NATURE WHATSOEVER, DIRECTLY OR INDIRECTLY, ARISING FROM THE USE OF THIS SPECIFICATION.

Table of Contents

1. Introduction
2. References
3. Binding of Complex Types
4. Binding of Simple Types
5. XML Binding Reference

1. Introduction

The information model defines a set of classes and data types in an abstract way. When faced with the real task of communicating data between systems these abstract concepts need to be bound to some physical representation, such as a stream of bytes in a computer file.

The document describes the required method of binding the information model when the physical representation is an XML Document. The binding rules are given primarily in the form of an XML Schema with the following target namespace: http://www.imsglobal.org/xsd/imsqti_v2p0. To assist developers who wish to check the validity of QTI XML documents using tools that support document type definitions (DTDs) the binding rules are also represented as a DTD, however, the DTD is not able to express all the constraints contained in the schema and document instances should validate against the schema. QTI document instances must validate against one of the schema or DTD.

2. References

MathML
Mathematical Markup Language (MathML), Version Version 2.0 (Second Edition)
http://www.w3.org/TR/2003/REC-MathML2-20031021/
Published: 2003-10-21
XHTML
XHTML 1.1: The Extensible HyperText Markup Language

3. Binding of Complex Types

Complex types, those that contain other objects through composition and/or have attributes, are represented in the schema as elements with complex content in a straightforward way. Classes that are used as base classes (typically labeled abstract in the model) are used to define an element group consisting of a single choice listing all the non-abstract classes derived from them. Classes with attributes are used to define attribute groups and those that contain other objects (including through inheritance) are used to define element groups describing them.

Elements defined by [XHTML] are not imported directly from an external schema but are instead re-declared as part of the QTI schema. At the time of writing the use of schema for XHTML is at an experimental stage. However, the math element defined by [MathML] is imported from the MathML schema. Note that the use of the MathML schema excludes the use of the entity declarations for mathematical symbols defined in the original MathML DTD and therefore these should not be used for referring to characters within QTI document instances.

4. Binding of Simple Types

Simple datatypes are bound directly to the closest equivalent type in XML Schema, for example, boolean is bound directly to xsd:boolean. Enumerations are bound as enumerated restrictions of xsd:NMTOKEN.

The information model says nothing about how simple types are to be represented in text. For example, the boolean type is an abstract boolean which can be either logically true or logically false. By binding these simple types using XML Schema they automatically inherit the lexical bindings described there. A lexical binding is just a set of rules for representing the abstract type as a run of text characters. For example, XML Schema allows the following strings to represent the values of xsd:boolean: "true", "false", "1" and "0".

XML DTDs have a smaller vocabulary for defining simple types and is therefore not able to impose the same lexical constraints as the schema. Applications that generate QTI document instances that validate against the DTD must still use the same lexical bindings defined by schema even though these will not be checked automatically by the XML parser. For example, in the DTD the boolean type is bound only to NMTOKEN and therefore the XML parser will permit many more strings than the four listed above. However, strings such as "yes" and "no" are still forbidden.

5. XML Binding Reference

<a>

Description: Defined by XHTML

Context:

    See:

    Attributes:

    • id (optional).
      Data type = identifier.Type
    • class (optional).
      Data type = list of styleclass.Type
    • xml:lang (optional).
    • label (optional).
      Data type = string256.Type
    • href (required).
      Data type = uri.Type
    • type (optional).
      Data type = mimeType.Type

    Elements:

    <abbr>

    Description: Defined by XHTML

    Context:

      See:

      Attributes:

      • id (optional).
        Data type = identifier.Type
      • class (optional).
        Data type = list of styleclass.Type
      • xml:lang (optional).
      • label (optional).
        Data type = string256.Type

      Elements:

      <acronym>

      Description: Defined by XHTML

      Context:

        See:

        Attributes:

        • id (optional).
          Data type = identifier.Type
        • class (optional).
          Data type = list of styleclass.Type
        • xml:lang (optional).
        • label (optional).
          Data type = string256.Type

        Elements:

        <adaptive>

        Description: Profile flag for the adaptive items feature.

        Context:

        <address>

        Description: Defined by XHTML

        Context:

          See:

          Attributes:

          • id (optional).
            Data type = identifier.Type
          • class (optional).
            Data type = list of styleclass.Type
          • xml:lang (optional).
          • label (optional).
            Data type = string256.Type

          Elements:

          <and>

          Description: An expression that performs a boolean and.

          Context:

            See:

            Elements:

            <anyN>

            Description: An expression for testing groups of boolean sub-expressions.

            Context:

              See:

              Attributes:

              • min (required).
                Data type = integer.Type
              • max (required).
                Data type = integer.Type

              Elements:

              <areaMapEntry>

              Description: Defines an area for mapping a set of points onto a single real number.

              Context:

              Attributes:

              • shape (required).
                Data type = shape.Type
              • coords (required).
                Data type = coords.Type
              • mappedValue (required).
                Data type = float.Type

              <areaMapping>

              Description: Defines a mapping from the set of points to real numbers using areas.

              Context:

              Attributes:

              • lowerBound (optional).
                Data type = float.Type
              • upperBound (optional).
                Data type = float.Type
              • defaultValue (required).
                Data type = float.Type

              Elements:

              <assessmentItem>

              Description: The root element for QTI items

              Context:

                Can be the root element of an XML document.

                Attributes:

                • identifier (required).
                  Data type = string.Type
                • title (required).
                  Data type = string.Type
                • label (optional).
                  Data type = string256.Type
                • xml:lang (optional).
                • adaptive (required).
                  Data type = boolean.Type
                • timeDependent (required).
                  Data type = boolean.Type
                • toolName (optional).
                  Data type = string256.Type
                • toolVersion (optional).
                  Data type = string256.Type

                Elements:

                associableChoice.ElementGroup

                Description: The group of elements that are used in association-type interactions.

                Group members: <associableHotspot>, <gap>, <gapImg>, <gapText>, <simpleAssociableChoice>

                Context:

                  Not applicable.

                  <associableHotspot>

                  Description: An element that defines a hot area of a graphic for association tasks.

                  Context:

                  Attributes:

                  • id (optional).
                    Data type = identifier.Type
                  • class (optional).
                    Data type = list of styleclass.Type
                  • xml:lang (optional).
                  • label (optional).
                    Data type = string256.Type
                  • identifier (required).
                    Data type = identifier.Type
                  • fixed (optional).
                    Data type = boolean.Type
                  • matchGroup (optional).
                    Data type = list of identifier.Type
                  • shape (required).
                    Data type = shape.Type
                  • coords (required).
                    Data type = coords.Type
                  • hotspotLabel (optional).
                    Data type = string256.Type
                  • matchMax (required).
                    Data type = integer.Type

                  <associateInteraction>

                  Description: Interaction in which the candidate must identify pairs of choices from a single set.

                  Context:

                    See:

                    Attributes:

                    • id (optional).
                      Data type = identifier.Type
                    • class (optional).
                      Data type = list of styleclass.Type
                    • xml:lang (optional).
                    • label (optional).
                      Data type = string256.Type
                    • responseIdentifier (required).
                      Data type = identifier.Type
                    • shuffle (required).
                      Data type = boolean.Type
                    • maxAssociations (required).
                      Data type = integer.Type

                    Elements:

                    atomicBlock.ElementGroup

                    Description: A group of elements that provide structure but that can only contain elements behaving like spans of text.

                    Group members: <address>, <h1>, <h2>, <h3>, <h4>, <h5>, <h6>, <p>, <pre>

                    Context:

                      See:

                      atomicInline.ElementGroup

                      Description: A group of empty elements that behave like spans of text

                      Group members: <br>, <img>

                      Context:

                        See:

                        <b>

                        Description: Defined by XHTML

                        Context:

                          See:

                          Attributes:

                          • id (optional).
                            Data type = identifier.Type
                          • class (optional).
                            Data type = list of styleclass.Type
                          • xml:lang (optional).
                          • label (optional).
                            Data type = string256.Type

                          Elements:

                          <bankProfile>

                          Description: An element for describing the capabilities or requirements of an item-bank system.

                          Context:

                            Can be the root element of an XML document.

                            Elements:

                            baseType.Type

                            One of the following symbolic values:

                            • boolean
                            • directedPair
                            • duration
                            • file
                            • float
                            • identifier
                            • integer
                            • pair
                            • point
                            • string
                            • uri

                            <baseValue>

                            Description: A simple expression returning a constant value of the given base-type.

                            Context:

                              See:

                              Attributes:

                              • baseType (required).
                                Data type = baseType.Type

                              <big>

                              Description: Defined by XHTML

                              Context:

                                See:

                                Attributes:

                                • id (optional).
                                  Data type = identifier.Type
                                • class (optional).
                                  Data type = list of styleclass.Type
                                • xml:lang (optional).
                                • label (optional).
                                  Data type = string256.Type

                                Elements:

                                block.ElementGroup

                                Description: A group of elements that provide structure to the item body.

                                Group members: <address>, <associateInteraction>, <blockquote>, <choiceInteraction>, <customInteraction>, <div>, <dl>, <drawingInteraction>, <extendedTextInteraction>, <feedbackBlock>, <gapMatchInteraction>, <graphicAssociateInteraction>, <graphicGapMatchInteraction>, <graphicOrderInteraction>, <h1>, <h2>, <h3>, <h4>, <h5>, <h6>, <hotspotInteraction>, <hottextInteraction>, <hr>, <m:math>, <matchInteraction>, <ol>, <orderInteraction>, <p>, <positionObjectStage>, <pre>, <rubricBlock>, <selectPointInteraction>, <sliderInteraction>, <table>, <templateBlock>, <ul>, <uploadInteraction>

                                Context:

                                blockInteraction.ElementGroup

                                Description: The group of interactions which have inherent structure of their own.

                                Group members: <associateInteraction>, <choiceInteraction>, <drawingInteraction>, <extendedTextInteraction>, <gapMatchInteraction>, <graphicAssociateInteraction>, <graphicGapMatchInteraction>, <graphicOrderInteraction>, <hotspotInteraction>, <hottextInteraction>, <matchInteraction>, <orderInteraction>, <selectPointInteraction>, <sliderInteraction>, <uploadInteraction>

                                Context:

                                  See:

                                  blockStatic.ElementGroup

                                  Description: A group of elements that provide structure excluding interactions.

                                  Group members: <address>, <blockquote>, <div>, <dl>, <feedbackBlock>, <h1>, <h2>, <h3>, <h4>, <h5>, <h6>, <hr>, <m:math>, <ol>, <p>, <pre>, <rubricBlock>, <table>, <templateBlock>, <ul>

                                  Context:

                                  See:

                                  <blockquote>

                                  Description: Defined by XHTML

                                  Context:

                                    See:

                                    Attributes:

                                    • id (optional).
                                      Data type = identifier.Type
                                    • class (optional).
                                      Data type = list of styleclass.Type
                                    • xml:lang (optional).
                                    • label (optional).
                                      Data type = string256.Type
                                    • cite (optional).
                                      Data type = uri.Type

                                    Elements:

                                    bodyElement.ElementGroup

                                    Description: The group of elements used to describe the structure, material and interactions within the item body.

                                    Group members: <a>, <abbr>, <acronym>, <address>, <associableHotspot>, <associateInteraction>, <b>, <big>, <blockquote>, <br>, <caption>, <choiceInteraction>, <cite>, <code>, <col>, <colgroup>, <customInteraction>, <dd>, <dfn>, <div>, <dl>, <drawingInteraction>, <dt>, <em>, <endAttemptInteraction>, <extendedTextInteraction>, <feedbackBlock>, <feedbackInline>, <gap>, <gapImg>, <gapMatchInteraction>, <gapText>, <graphicAssociateInteraction>, <graphicGapMatchInteraction>, <graphicOrderInteraction>, <h1>, <h2>, <h3>, <h4>, <h5>, <h6>, <hotspotChoice>, <hotspotInteraction>, <hottext>, <hottextInteraction>, <hr>, <i>, <img>, <inlineChoice>, <inlineChoiceInteraction>, <itemBody>, <kbd>, <li>, <matchInteraction>, <object>, <ol>, <orderInteraction>, <p>, <positionObjectInteraction>, <pre>, <printedVariable>, <prompt>, <q>, <rubricBlock>, <samp>, <selectPointInteraction>, <simpleAssociableChoice>, <simpleChoice>, <sliderInteraction>, <small>, <span>, <strong>, <sub>, <sup>, <table>, <tbody>, <td>, <templateBlock>, <templateInline>, <textEntryInteraction>, <tfoot>, <th>, <thead>, <tr>, <tt>, <ul>, <uploadInteraction>, <var>

                                    Context:

                                      Not applicable.

                                      boolean.Type

                                      A trivial restriction of xsd:boolean.

                                      <br>

                                      Description: Defined by XHTML

                                      Context:

                                        See:

                                        Attributes:

                                        • id (optional).
                                          Data type = identifier.Type
                                        • class (optional).
                                          Data type = list of styleclass.Type
                                        • xml:lang (optional).
                                        • label (optional).
                                          Data type = string256.Type

                                        <caption>

                                        Description: Defined by XHTML

                                        Context:

                                        • Occurs [0..1] within table

                                        Attributes:

                                        • id (optional).
                                          Data type = identifier.Type
                                        • class (optional).
                                          Data type = list of styleclass.Type
                                        • xml:lang (optional).
                                        • label (optional).
                                          Data type = string256.Type

                                        Elements:

                                        cardinality.Type

                                        One of the following symbolic values:

                                        • multiple
                                        • ordered
                                        • record
                                        • single

                                        <categorizedStatistic>

                                        Description: A categorized statistic, such as a score-conversion table, expressed as a mapping.

                                        Context:

                                          See:

                                          Attributes:

                                          • name (required).
                                            Data type = identifier.Type
                                          • glossary (optional).
                                            Data type = uri.Type
                                          • context (required).
                                            Data type = uri.Type
                                          • caseCount (optional).
                                            Data type = integer.Type
                                          • stdError (optional).
                                            Data type = float.Type
                                          • stdDeviation (optional).
                                            Data type = float.Type
                                          • lastUpdated (optional).
                                            Data type = date.Type

                                          Elements:

                                          choice.ElementGroup

                                          Description: The group of elements that provide choices from which the candidate may select a response.

                                          Group members: <associableHotspot>, <gap>, <gapImg>, <gapText>, <hotspotChoice>, <hottext>, <inlineChoice>, <simpleAssociableChoice>, <simpleChoice>

                                          Context:

                                            Not applicable.

                                            <choiceInteraction>

                                            Description: The element that represents simple multiple choice and multiple-response interactions.

                                            Context:

                                              See:

                                              Attributes:

                                              • id (optional).
                                                Data type = identifier.Type
                                              • class (optional).
                                                Data type = list of styleclass.Type
                                              • xml:lang (optional).
                                              • label (optional).
                                                Data type = string256.Type
                                              • responseIdentifier (required).
                                                Data type = identifier.Type
                                              • shuffle (required).
                                                Data type = boolean.Type
                                              • maxChoices (required).
                                                Data type = integer.Type

                                              Elements:

                                              <cite>

                                              Description: Defined by XHTML

                                              Context:

                                                See:

                                                Attributes:

                                                • id (optional).
                                                  Data type = identifier.Type
                                                • class (optional).
                                                  Data type = list of styleclass.Type
                                                • xml:lang (optional).
                                                • label (optional).
                                                  Data type = string256.Type

                                                Elements:

                                                <code>

                                                Description: Defined by XHTML

                                                Context:

                                                  See:

                                                  Attributes:

                                                  • id (optional).
                                                    Data type = identifier.Type
                                                  • class (optional).
                                                    Data type = list of styleclass.Type
                                                  • xml:lang (optional).
                                                  • label (optional).
                                                    Data type = string256.Type

                                                  Elements:

                                                  <col>

                                                  Description: Defined by XHTML

                                                  Context:

                                                  Attributes:

                                                  • id (optional).
                                                    Data type = identifier.Type
                                                  • class (optional).
                                                    Data type = list of styleclass.Type
                                                  • xml:lang (optional).
                                                  • label (optional).
                                                    Data type = string256.Type

                                                  <colgroup>

                                                  Description: Defined by XHTML

                                                  Context:

                                                  • Occurs [*] within table

                                                  Attributes:

                                                  • id (optional).
                                                    Data type = identifier.Type
                                                  • class (optional).
                                                    Data type = list of styleclass.Type
                                                  • xml:lang (optional).
                                                  • label (optional).
                                                    Data type = string256.Type

                                                  Elements:

                                                  <composite>

                                                  Description: Profile flag for the composite items feature.

                                                  Context:

                                                  <contains>

                                                  Description: An expression that tests a container to determine if it contains another.

                                                  Context:

                                                    See:

                                                    Elements:

                                                    <contentProfile>

                                                    Description: An element for describing the capabilities or requirements of a system that handles QTI content.

                                                    Context:

                                                      Can be the root element of an XML document.

                                                      Elements:

                                                      coords.Type

                                                      A trivial restriction of xsd:string.

                                                      <correct>

                                                      Description: A simple expression returning the correct value associated with a response variable.

                                                      Context:

                                                        See:

                                                        Attributes:

                                                        • identifier (required).
                                                          Data type = identifier.Type

                                                        <correctResponse>

                                                        Description: Declares the (or a) correct response for a response variable.

                                                        Context:

                                                        Attributes:

                                                        • interpretation (optional).
                                                          Data type = string.Type

                                                        Elements:

                                                        <customInteraction>

                                                        Description: An element that allows extensions to QTI to be developed for interaction types not covered by the information model.

                                                        Context:

                                                          See:

                                                          Attributes:

                                                          • id (optional).
                                                            Data type = identifier.Type
                                                          • class (optional).
                                                            Data type = list of styleclass.Type
                                                          • xml:lang (optional).
                                                          • label (optional).
                                                            Data type = string256.Type
                                                          • responseIdentifier (required).
                                                            Data type = identifier.Type
                                                          • Attributes from other namespaces

                                                          Elements:

                                                          • Elements from any namespace

                                                          <customOperator>

                                                          Description: An element allowing externally defined expressions to be used.

                                                          Context:

                                                            See:

                                                            Attributes:

                                                            • class (optional).
                                                              Data type = identifier.Type
                                                            • definition (optional).
                                                              Data type = uri.Type
                                                            • Attributes from other namespaces

                                                            Elements:

                                                            date.Type

                                                            A trivial restriction of xsd:date.

                                                            <dd>

                                                            Description: Defined by XHTML

                                                            Context:

                                                              See:

                                                              Attributes:

                                                              • id (optional).
                                                                Data type = identifier.Type
                                                              • class (optional).
                                                                Data type = list of styleclass.Type
                                                              • xml:lang (optional).
                                                              • label (optional).
                                                                Data type = string256.Type

                                                              Elements:

                                                              <default>

                                                              Description: A simple expression returning the default value of an item variable.

                                                              Context:

                                                                See:

                                                                Attributes:

                                                                • identifier (required).
                                                                  Data type = identifier.Type

                                                                <defaultValue>

                                                                Description: Defines the default value for an item variable.

                                                                Context:

                                                                Attributes:

                                                                • interpretation (optional).
                                                                  Data type = string.Type

                                                                Elements:

                                                                <delete>

                                                                Description: An expression that derives a new container by removing a given value from an existing one.

                                                                Context:

                                                                  See:

                                                                  Elements:

                                                                  <dfn>

                                                                  Description: Defined by XHTML

                                                                  Context:

                                                                    See:

                                                                    Attributes:

                                                                    • id (optional).
                                                                      Data type = identifier.Type
                                                                    • class (optional).
                                                                      Data type = list of styleclass.Type
                                                                    • xml:lang (optional).
                                                                    • label (optional).
                                                                      Data type = string256.Type

                                                                    Elements:

                                                                    <div>

                                                                    Description: Defined by XHTML

                                                                    Context:

                                                                      See:

                                                                      Attributes:

                                                                      • id (optional).
                                                                        Data type = identifier.Type
                                                                      • class (optional).
                                                                        Data type = list of styleclass.Type
                                                                      • xml:lang (optional).
                                                                      • label (optional).
                                                                        Data type = string256.Type

                                                                      Elements:

                                                                      <divide>

                                                                      Description: An expression for dividing one number by another.

                                                                      Context:

                                                                        See:

                                                                        Elements:

                                                                        <dl>

                                                                        Description: Defined by XHTML

                                                                        Context:

                                                                          See:

                                                                          Attributes:

                                                                          • id (optional).
                                                                            Data type = identifier.Type
                                                                          • class (optional).
                                                                            Data type = list of styleclass.Type
                                                                          • xml:lang (optional).
                                                                          • label (optional).
                                                                            Data type = string256.Type

                                                                          Elements:

                                                                          dlElement.ElementGroup

                                                                          Description: Elements that can appear within <dl>.

                                                                          Group members: <dd>, <dt>

                                                                          Context:

                                                                          • Occurs [*] within dl

                                                                          <drawingInteraction>

                                                                          Description: Interaction in which the candidate draws freely on a given backdrop image.

                                                                          Context:

                                                                            See:

                                                                            Attributes:

                                                                            • id (optional).
                                                                              Data type = identifier.Type
                                                                            • class (optional).
                                                                              Data type = list of styleclass.Type
                                                                            • xml:lang (optional).
                                                                            • label (optional).
                                                                              Data type = string256.Type
                                                                            • responseIdentifier (required).
                                                                              Data type = identifier.Type

                                                                            Elements:

                                                                            <dt>

                                                                            Description: Defined by XHTML

                                                                            Context:

                                                                              See:

                                                                              Attributes:

                                                                              • id (optional).
                                                                                Data type = identifier.Type
                                                                              • class (optional).
                                                                                Data type = list of styleclass.Type
                                                                              • xml:lang (optional).
                                                                              • label (optional).
                                                                                Data type = string256.Type

                                                                              Elements:

                                                                              <durationGTE>

                                                                              Description: An expression for testing the greater-than-or-equal relation between two durations.

                                                                              Context:

                                                                                See:

                                                                                Elements:

                                                                                <durationLT>

                                                                                Description: An expression for testing the less-than relation between two durations.

                                                                                Context:

                                                                                  See:

                                                                                  Elements:

                                                                                  <em>

                                                                                  Description: Defined by XHTML

                                                                                  Context:

                                                                                    See:

                                                                                    Attributes:

                                                                                    • id (optional).
                                                                                      Data type = identifier.Type
                                                                                    • class (optional).
                                                                                      Data type = list of styleclass.Type
                                                                                    • xml:lang (optional).
                                                                                    • label (optional).
                                                                                      Data type = string256.Type

                                                                                    Elements:

                                                                                    <endAttemptInteraction>

                                                                                    Description: A special interaction for providing alternative ways to end an attempt.

                                                                                    Context:

                                                                                      See:

                                                                                      Attributes:

                                                                                      • id (optional).
                                                                                        Data type = identifier.Type
                                                                                      • class (optional).
                                                                                        Data type = list of styleclass.Type
                                                                                      • xml:lang (optional).
                                                                                      • label (optional).
                                                                                        Data type = string256.Type
                                                                                      • responseIdentifier (required).
                                                                                        Data type = identifier.Type
                                                                                      • title (required).
                                                                                        Data type = string.Type

                                                                                      <equal>

                                                                                      Description: An expression for testing two numeric values for equality.

                                                                                      Context:

                                                                                        See:

                                                                                        Attributes:

                                                                                        • toleranceMode (required).
                                                                                          Data type = toleranceMode.Type
                                                                                        • tolerance (optional).
                                                                                          Data type = list of float.Type

                                                                                        Elements:

                                                                                        <equalRounded>

                                                                                        Description: An expression for testing two numeric values for equality after rounding.

                                                                                        Context:

                                                                                          See:

                                                                                          Attributes:

                                                                                          • roundingMode (required).
                                                                                            Data type = roundingMode.Type
                                                                                          • figures (required).
                                                                                            Data type = integer.Type

                                                                                          Elements:

                                                                                          <exitResponse>

                                                                                          Description: A response rule that terminates response processing immediately.

                                                                                          Context:

                                                                                            See:

                                                                                            <exitTemplate>

                                                                                            Description: A template rule that terminates template processing immediately.

                                                                                            Context:

                                                                                              See:

                                                                                              expression.ElementGroup

                                                                                              Description: The group of elements that are used to create expressions for setting variable values and controlling conditional groups of rules.

                                                                                              Group members: <and>, <anyN>, <baseValue>, <contains>, <correct>, <customOperator>, <default>, <delete>, <divide>, <durationGTE>, <durationLT>, <equal>, <equalRounded>, <fieldValue>, <gt>, <gte>, <index>, <inside>, <integerDivide>, <integerModulus>, <integerToFloat>, <isNull>, <lt>, <lte>, <mapResponse>, <mapResponsePoint>, <match>, <member>, <multiple>, <not>, <null>, <or>, <ordered>, <patternMatch>, <power>, <product>, <random>, <randomFloat>, <randomInteger>, <round>, <stringMatch>, <substring>, <subtract>, <sum>, <truncate>, <variable>

                                                                                              Context:

                                                                                              <extendedTextInteraction>

                                                                                              Description: Interaction that allows the candidate to supply an extended free-text response.

                                                                                              Context:

                                                                                                See:

                                                                                                Attributes:

                                                                                                • id (optional).
                                                                                                  Data type = identifier.Type
                                                                                                • class (optional).
                                                                                                  Data type = list of styleclass.Type
                                                                                                • xml:lang (optional).
                                                                                                • label (optional).
                                                                                                  Data type = string256.Type
                                                                                                • responseIdentifier (required).
                                                                                                  Data type = identifier.Type
                                                                                                • base (optional).
                                                                                                  Data type = integer.Type
                                                                                                • stringIdentifier (optional).
                                                                                                  Data type = identifier.Type
                                                                                                • expectedLength (optional).
                                                                                                  Data type = integer.Type
                                                                                                • patternMask (optional).
                                                                                                  Data type = string.Type
                                                                                                • placeholderText (optional).
                                                                                                  Data type = string.Type
                                                                                                • maxStrings (optional).
                                                                                                  Data type = integer.Type
                                                                                                • expectedLines (optional).
                                                                                                  Data type = integer.Type

                                                                                                Elements:

                                                                                                <feedbackBlock>

                                                                                                Description: A structural part of the item body whose visibility can be conditionally controlled by the current outcomes.

                                                                                                Context:

                                                                                                  See:

                                                                                                  Attributes:

                                                                                                  • outcomeIdentifier (required).
                                                                                                    Data type = identifier.Type
                                                                                                  • showHide (required).
                                                                                                    Data type = showHide.Type
                                                                                                  • identifier (required).
                                                                                                    Data type = identifier.Type
                                                                                                  • id (optional).
                                                                                                    Data type = identifier.Type
                                                                                                  • class (optional).
                                                                                                    Data type = list of styleclass.Type
                                                                                                  • xml:lang (optional).
                                                                                                  • label (optional).
                                                                                                    Data type = string256.Type

                                                                                                  Elements:

                                                                                                  feedbackElement.ElementGroup

                                                                                                  Description: Elements whose visibility can be conditionally controlled depending on the current outcomes.

                                                                                                  Group members: <feedbackBlock>, <feedbackInline>

                                                                                                  Context:

                                                                                                    Not applicable.

                                                                                                    <feedbackInline>

                                                                                                    Description: A span of text (or equivalent) whose visibility can be conditionally controlled by the current outcomes.

                                                                                                    Context:

                                                                                                      See:

                                                                                                      Attributes:

                                                                                                      • outcomeIdentifier (required).
                                                                                                        Data type = identifier.Type
                                                                                                      • showHide (required).
                                                                                                        Data type = showHide.Type
                                                                                                      • identifier (required).
                                                                                                        Data type = identifier.Type
                                                                                                      • id (optional).
                                                                                                        Data type = identifier.Type
                                                                                                      • class (optional).
                                                                                                        Data type = list of styleclass.Type
                                                                                                      • xml:lang (optional).
                                                                                                      • label (optional).
                                                                                                        Data type = string256.Type

                                                                                                      Elements:

                                                                                                      <feedbackIntegrated>

                                                                                                      Description: Profile flag for the integrated feedback feature.

                                                                                                      Context:

                                                                                                      <feedbackModal>

                                                                                                      Description: Profile flag for the modal feedback feature.

                                                                                                      Context:

                                                                                                      <feedbackType>

                                                                                                      Context:

                                                                                                      Content: a value of type feedbackType.Type.

                                                                                                      feedbackType.Type

                                                                                                      One of the following symbolic values:

                                                                                                      • adaptive
                                                                                                      • nonadaptive
                                                                                                      • none

                                                                                                      <fieldValue>

                                                                                                      Description: An expression that extracts a single field value from a record container.

                                                                                                      Context:

                                                                                                        See:

                                                                                                        Attributes:

                                                                                                        • fieldIdentifier (required).
                                                                                                          Data type = identifier.Type

                                                                                                        Elements:

                                                                                                        float.Type

                                                                                                        A trivial restriction of xsd:float.

                                                                                                        flow.ElementGroup

                                                                                                        Description: A group of elements that can appear in contexts where either further structure or spans of text are allowed.

                                                                                                        Group members: <a>, <abbr>, <acronym>, <address>, <associateInteraction>, <b>, <big>, <blockquote>, <br>, <choiceInteraction>, <cite>, <code>, <customInteraction>, <dfn>, <div>, <dl>, <drawingInteraction>, <em>, <endAttemptInteraction>, <extendedTextInteraction>, <feedbackBlock>, <feedbackInline>, <gapMatchInteraction>, <graphicAssociateInteraction>, <graphicGapMatchInteraction>, <graphicOrderInteraction>, <h1>, <h2>, <h3>, <h4>, <h5>, <h6>, <hotspotInteraction>, <hottext>, <hottextInteraction>, <hr>, <i>, <img>, <inlineChoiceInteraction>, <kbd>, <m:math>, <matchInteraction>, <object>, <ol>, <orderInteraction>, <p>, <pre>, <printedVariable>, <q>, <rubricBlock>, <samp>, <selectPointInteraction>, <sliderInteraction>, <small>, <span>, <strong>, <sub>, <sup>, <table>, <templateBlock>, <templateInline>, <textEntryInteraction>, <tt>, <ul>, <uploadInteraction>, <var>

                                                                                                        Context:

                                                                                                        See:

                                                                                                        flowStatic.ElementGroup

                                                                                                        Description: A group of elements that can appear in contexts where either further structure or spans of text are allowed excluding interactions.

                                                                                                        Group members: <a>, <abbr>, <acronym>, <address>, <b>, <big>, <blockquote>, <br>, <cite>, <code>, <dfn>, <div>, <dl>, <em>, <feedbackBlock>, <feedbackInline>, <h1>, <h2>, <h3>, <h4>, <h5>, <h6>, <hottext>, <hr>, <i>, <img>, <kbd>, <m:math>, <object>, <ol>, <p>, <pre>, <printedVariable>, <q>, <rubricBlock>, <samp>, <small>, <span>, <strong>, <sub>, <sup>, <table>, <templateBlock>, <templateInline>, <tt>, <ul>, <var>

                                                                                                        Context:

                                                                                                        See:

                                                                                                        <gap>

                                                                                                        Description: Defines the position of a gap in the text for gap-filling tasks.

                                                                                                        Context:

                                                                                                          See:

                                                                                                          Attributes:

                                                                                                          • id (optional).
                                                                                                            Data type = identifier.Type
                                                                                                          • class (optional).
                                                                                                            Data type = list of styleclass.Type
                                                                                                          • xml:lang (optional).
                                                                                                          • label (optional).
                                                                                                            Data type = string256.Type
                                                                                                          • identifier (required).
                                                                                                            Data type = identifier.Type
                                                                                                          • fixed (optional).
                                                                                                            Data type = boolean.Type
                                                                                                          • matchGroup (optional).
                                                                                                            Data type = list of identifier.Type

                                                                                                          gapChoice.ElementGroup

                                                                                                          Description: A group of elements that can be used to define choices for gap-filling tasks.

                                                                                                          Group members: <gapImg>, <gapText>

                                                                                                          Context:

                                                                                                          <gapImg>

                                                                                                          Description: An image that can be used to fill a gap.

                                                                                                          Context:

                                                                                                          See:

                                                                                                          Attributes:

                                                                                                          • id (optional).
                                                                                                            Data type = identifier.Type
                                                                                                          • class (optional).
                                                                                                            Data type = list of styleclass.Type
                                                                                                          • xml:lang (optional).
                                                                                                          • label (optional).
                                                                                                            Data type = string256.Type
                                                                                                          • identifier (required).
                                                                                                            Data type = identifier.Type
                                                                                                          • fixed (optional).
                                                                                                            Data type = boolean.Type
                                                                                                          • matchGroup (optional).
                                                                                                            Data type = list of identifier.Type
                                                                                                          • matchMax (required).
                                                                                                            Data type = integer.Type
                                                                                                          • objectLabel (optional).
                                                                                                            Data type = string.Type

                                                                                                          Elements:

                                                                                                          <gapMatchInteraction>

                                                                                                          Description: An interaction in which the candidate fills gaps in a passage of text from a set of predefined choices.

                                                                                                          Context:

                                                                                                            See:

                                                                                                            Attributes:

                                                                                                            • id (optional).
                                                                                                              Data type = identifier.Type
                                                                                                            • class (optional).
                                                                                                              Data type = list of styleclass.Type
                                                                                                            • xml:lang (optional).
                                                                                                            • label (optional).
                                                                                                              Data type = string256.Type
                                                                                                            • responseIdentifier (required).
                                                                                                              Data type = identifier.Type
                                                                                                            • shuffle (required).
                                                                                                              Data type = boolean.Type

                                                                                                            Elements:

                                                                                                            <gapText>

                                                                                                            Description: A simple run of text that can be used to fill a gap.

                                                                                                            Context:

                                                                                                              See:

                                                                                                              Attributes:

                                                                                                              • id (optional).
                                                                                                                Data type = identifier.Type
                                                                                                              • class (optional).
                                                                                                                Data type = list of styleclass.Type
                                                                                                              • xml:lang (optional).
                                                                                                              • label (optional).
                                                                                                                Data type = string256.Type
                                                                                                              • identifier (required).
                                                                                                                Data type = identifier.Type
                                                                                                              • fixed (optional).
                                                                                                                Data type = boolean.Type
                                                                                                              • matchGroup (optional).
                                                                                                                Data type = list of identifier.Type
                                                                                                              • matchMax (required).
                                                                                                                Data type = integer.Type

                                                                                                              <graphicAssociateInteraction>

                                                                                                              Description: Interaction in which the candidate associates pairs of pre-defined hotspots on an image.

                                                                                                              Context:

                                                                                                                See:

                                                                                                                Attributes:

                                                                                                                • id (optional).
                                                                                                                  Data type = identifier.Type
                                                                                                                • class (optional).
                                                                                                                  Data type = list of styleclass.Type
                                                                                                                • xml:lang (optional).
                                                                                                                • label (optional).
                                                                                                                  Data type = string256.Type
                                                                                                                • responseIdentifier (required).
                                                                                                                  Data type = identifier.Type
                                                                                                                • maxAssociations (required).
                                                                                                                  Data type = integer.Type

                                                                                                                Elements:

                                                                                                                <graphicGapMatchInteraction>

                                                                                                                Description: Interaction in which the candidate fills gaps within a given image, e.g., through drag-and-drop.

                                                                                                                Context:

                                                                                                                  See:

                                                                                                                  Attributes:

                                                                                                                  • id (optional).
                                                                                                                    Data type = identifier.Type
                                                                                                                  • class (optional).
                                                                                                                    Data type = list of styleclass.Type
                                                                                                                  • xml:lang (optional).
                                                                                                                  • label (optional).
                                                                                                                    Data type = string256.Type
                                                                                                                  • responseIdentifier (required).
                                                                                                                    Data type = identifier.Type

                                                                                                                  Elements:

                                                                                                                  graphicInteraction.ElementGroup

                                                                                                                  Description: A group of elements for describing image-based tasks.

                                                                                                                  Group members: <graphicAssociateInteraction>, <graphicGapMatchInteraction>, <graphicOrderInteraction>, <hotspotInteraction>, <selectPointInteraction>

                                                                                                                  Context:

                                                                                                                    See:

                                                                                                                    <graphicOrderInteraction>

                                                                                                                    Description: Interaction in which the candidate orders a set of predefined hotspots on an image.

                                                                                                                    Context:

                                                                                                                      See:

                                                                                                                      Attributes:

                                                                                                                      • id (optional).
                                                                                                                        Data type = identifier.Type
                                                                                                                      • class (optional).
                                                                                                                        Data type = list of styleclass.Type
                                                                                                                      • xml:lang (optional).
                                                                                                                      • label (optional).
                                                                                                                        Data type = string256.Type
                                                                                                                      • responseIdentifier (required).
                                                                                                                        Data type = identifier.Type

                                                                                                                      Elements:

                                                                                                                      <gt>

                                                                                                                      Description: An expression for testing the greater-than relation between two numbers.

                                                                                                                      Context:

                                                                                                                        See:

                                                                                                                        Elements:

                                                                                                                        <gte>

                                                                                                                        Description: An expression for testing the greater-than-or-equal relation between two numbers.

                                                                                                                        Context:

                                                                                                                          See:

                                                                                                                          Elements:

                                                                                                                          <h1>

                                                                                                                          Description: Defined by XHTML

                                                                                                                          Context:

                                                                                                                            See:

                                                                                                                            Attributes:

                                                                                                                            • id (optional).
                                                                                                                              Data type = identifier.Type
                                                                                                                            • class (optional).
                                                                                                                              Data type = list of styleclass.Type
                                                                                                                            • xml:lang (optional).
                                                                                                                            • label (optional).
                                                                                                                              Data type = string256.Type

                                                                                                                            Elements:

                                                                                                                            <h2>

                                                                                                                            Description: Defined by XHTML

                                                                                                                            Context:

                                                                                                                              See:

                                                                                                                              Attributes:

                                                                                                                              • id (optional).
                                                                                                                                Data type = identifier.Type
                                                                                                                              • class (optional).
                                                                                                                                Data type = list of styleclass.Type
                                                                                                                              • xml:lang (optional).
                                                                                                                              • label (optional).
                                                                                                                                Data type = string256.Type

                                                                                                                              Elements:

                                                                                                                              <h3>

                                                                                                                              Description: Defined by XHTML

                                                                                                                              Context:

                                                                                                                                See:

                                                                                                                                Attributes:

                                                                                                                                • id (optional).
                                                                                                                                  Data type = identifier.Type
                                                                                                                                • class (optional).
                                                                                                                                  Data type = list of styleclass.Type
                                                                                                                                • xml:lang (optional).
                                                                                                                                • label (optional).
                                                                                                                                  Data type = string256.Type

                                                                                                                                Elements:

                                                                                                                                <h4>

                                                                                                                                Description: Defined by XHTML

                                                                                                                                Context:

                                                                                                                                  See:

                                                                                                                                  Attributes:

                                                                                                                                  • id (optional).
                                                                                                                                    Data type = identifier.Type
                                                                                                                                  • class (optional).
                                                                                                                                    Data type = list of styleclass.Type
                                                                                                                                  • xml:lang (optional).
                                                                                                                                  • label (optional).
                                                                                                                                    Data type = string256.Type

                                                                                                                                  Elements:

                                                                                                                                  <h5>

                                                                                                                                  Description: Defined by XHTML

                                                                                                                                  Context:

                                                                                                                                    See:

                                                                                                                                    Attributes:

                                                                                                                                    • id (optional).
                                                                                                                                      Data type = identifier.Type
                                                                                                                                    • class (optional).
                                                                                                                                      Data type = list of styleclass.Type
                                                                                                                                    • xml:lang (optional).
                                                                                                                                    • label (optional).
                                                                                                                                      Data type = string256.Type

                                                                                                                                    Elements:

                                                                                                                                    <h6>

                                                                                                                                    Description: Defined by XHTML

                                                                                                                                    Context:

                                                                                                                                      See:

                                                                                                                                      Attributes:

                                                                                                                                      • id (optional).
                                                                                                                                        Data type = identifier.Type
                                                                                                                                      • class (optional).
                                                                                                                                        Data type = list of styleclass.Type
                                                                                                                                      • xml:lang (optional).
                                                                                                                                      • label (optional).
                                                                                                                                        Data type = string256.Type

                                                                                                                                      Elements:

                                                                                                                                      hotspot.ElementGroup

                                                                                                                                      Description: A group of elements that define hot areas of a graphic.

                                                                                                                                      Group members: <associableHotspot>, <hotspotChoice>

                                                                                                                                      Context:

                                                                                                                                        Not applicable.

                                                                                                                                        <hotspotChoice>

                                                                                                                                        Description: An element that defines a hot area of a graphic for simple area selection tasks.

                                                                                                                                        Context:

                                                                                                                                        Attributes:

                                                                                                                                        • id (optional).
                                                                                                                                          Data type = identifier.Type
                                                                                                                                        • class (optional).
                                                                                                                                          Data type = list of styleclass.Type
                                                                                                                                        • xml:lang (optional).
                                                                                                                                        • label (optional).
                                                                                                                                          Data type = string256.Type
                                                                                                                                        • identifier (required).
                                                                                                                                          Data type = identifier.Type
                                                                                                                                        • fixed (optional).
                                                                                                                                          Data type = boolean.Type
                                                                                                                                        • shape (required).
                                                                                                                                          Data type = shape.Type
                                                                                                                                        • coords (required).
                                                                                                                                          Data type = coords.Type
                                                                                                                                        • hotspotLabel (optional).
                                                                                                                                          Data type = string256.Type

                                                                                                                                        <hotspotInteraction>

                                                                                                                                        Description: Interaction in which the candidate selects pre-defined hotspots on an image.

                                                                                                                                        Context:

                                                                                                                                          See:

                                                                                                                                          Attributes:

                                                                                                                                          • id (optional).
                                                                                                                                            Data type = identifier.Type
                                                                                                                                          • class (optional).
                                                                                                                                            Data type = list of styleclass.Type
                                                                                                                                          • xml:lang (optional).
                                                                                                                                          • label (optional).
                                                                                                                                            Data type = string256.Type
                                                                                                                                          • responseIdentifier (required).
                                                                                                                                            Data type = identifier.Type
                                                                                                                                          • maxChoices (required).
                                                                                                                                            Data type = integer.Type

                                                                                                                                          Elements:

                                                                                                                                          <hottext>

                                                                                                                                          Description: Defines an area of hottext for hottext selection tasks.

                                                                                                                                          Context:

                                                                                                                                            See:

                                                                                                                                            Attributes:

                                                                                                                                            • id (optional).
                                                                                                                                              Data type = identifier.Type
                                                                                                                                            • class (optional).
                                                                                                                                              Data type = list of styleclass.Type
                                                                                                                                            • xml:lang (optional).
                                                                                                                                            • label (optional).
                                                                                                                                              Data type = string256.Type
                                                                                                                                            • identifier (required).
                                                                                                                                              Data type = identifier.Type
                                                                                                                                            • fixed (optional).
                                                                                                                                              Data type = boolean.Type

                                                                                                                                            Elements:

                                                                                                                                            <hottextInteraction>

                                                                                                                                            Description: Interaction in which the candidate selects pre-defined hot areas within the text.

                                                                                                                                            Context:

                                                                                                                                              See:

                                                                                                                                              Attributes:

                                                                                                                                              • id (optional).
                                                                                                                                                Data type = identifier.Type
                                                                                                                                              • class (optional).
                                                                                                                                                Data type = list of styleclass.Type
                                                                                                                                              • xml:lang (optional).
                                                                                                                                              • label (optional).
                                                                                                                                                Data type = string256.Type
                                                                                                                                              • responseIdentifier (required).
                                                                                                                                                Data type = identifier.Type
                                                                                                                                              • maxChoices (required).
                                                                                                                                                Data type = integer.Type

                                                                                                                                              Elements:

                                                                                                                                              <hr>

                                                                                                                                              Description: Defined by XHTML

                                                                                                                                              Context:

                                                                                                                                                See:

                                                                                                                                                Attributes:

                                                                                                                                                • id (optional).
                                                                                                                                                  Data type = identifier.Type
                                                                                                                                                • class (optional).
                                                                                                                                                  Data type = list of styleclass.Type
                                                                                                                                                • xml:lang (optional).
                                                                                                                                                • label (optional).
                                                                                                                                                  Data type = string256.Type

                                                                                                                                                <hypertextElement>

                                                                                                                                                Description: Profile flag for the XHTML hypertext element.

                                                                                                                                                Context:

                                                                                                                                                <i>

                                                                                                                                                Description: Defined by XHTML

                                                                                                                                                Context:

                                                                                                                                                  See:

                                                                                                                                                  Attributes:

                                                                                                                                                  • id (optional).
                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                  • class (optional).
                                                                                                                                                    Data type = list of styleclass.Type
                                                                                                                                                  • xml:lang (optional).
                                                                                                                                                  • label (optional).
                                                                                                                                                    Data type = string256.Type

                                                                                                                                                  Elements:

                                                                                                                                                  identifier.Type

                                                                                                                                                  A trivial restriction of xsd:NMTOKEN.

                                                                                                                                                  <imageElement>

                                                                                                                                                  Description: Profile flag for the XHTML image element.

                                                                                                                                                  Context:

                                                                                                                                                  <imageType>

                                                                                                                                                  Description: Profile element for identifying a specific image mime-type.

                                                                                                                                                  Context:

                                                                                                                                                  <img>

                                                                                                                                                  Description: Defined by XHTML

                                                                                                                                                  Context:

                                                                                                                                                    See:

                                                                                                                                                    Attributes:

                                                                                                                                                    • id (optional).
                                                                                                                                                      Data type = identifier.Type
                                                                                                                                                    • class (optional).
                                                                                                                                                      Data type = list of styleclass.Type
                                                                                                                                                    • xml:lang (optional).
                                                                                                                                                    • label (optional).
                                                                                                                                                      Data type = string256.Type
                                                                                                                                                    • src (required).
                                                                                                                                                      Data type = uri.Type
                                                                                                                                                    • alt (required).
                                                                                                                                                      Data type = string256.Type
                                                                                                                                                    • longdesc (optional).
                                                                                                                                                      Data type = uri.Type
                                                                                                                                                    • height (optional).
                                                                                                                                                      Data type = length.Type
                                                                                                                                                    • width (optional).
                                                                                                                                                      Data type = length.Type

                                                                                                                                                    <imsmd>

                                                                                                                                                    Description: Profile flag for IMS meta-data.

                                                                                                                                                    Context:

                                                                                                                                                    <imsqtimd>

                                                                                                                                                    Description: Profile flag for IMS QTI meta-data.

                                                                                                                                                    Context:

                                                                                                                                                    <index>

                                                                                                                                                    Description: An expression that extracts a single value from an ordered container.

                                                                                                                                                    Context:

                                                                                                                                                      See:

                                                                                                                                                      Attributes:

                                                                                                                                                      • n (required).
                                                                                                                                                        Data type = integer.Type

                                                                                                                                                      Elements:

                                                                                                                                                      inline.ElementGroup

                                                                                                                                                      Description: The group of elements that behave like spans of text.

                                                                                                                                                      Group members: <a>, <abbr>, <acronym>, <b>, <big>, <br>, <cite>, <code>, <dfn>, <em>, <endAttemptInteraction>, <feedbackInline>, <gap>, <hottext>, <i>, <img>, <inlineChoiceInteraction>, <kbd>, <m:math>, <object>, <printedVariable>, <q>, <samp>, <small>, <span>, <strong>, <sub>, <sup>, <templateInline>, <textEntryInteraction>, <tt>, <var>

                                                                                                                                                      Context:

                                                                                                                                                      <inlineChoice>

                                                                                                                                                      Description: A string of text that can be used to fill a gap.

                                                                                                                                                      Context:

                                                                                                                                                      Attributes:

                                                                                                                                                      • id (optional).
                                                                                                                                                        Data type = identifier.Type
                                                                                                                                                      • class (optional).
                                                                                                                                                        Data type = list of styleclass.Type
                                                                                                                                                      • xml:lang (optional).
                                                                                                                                                      • label (optional).
                                                                                                                                                        Data type = string256.Type
                                                                                                                                                      • identifier (required).
                                                                                                                                                        Data type = identifier.Type
                                                                                                                                                      • fixed (optional).
                                                                                                                                                        Data type = boolean.Type

                                                                                                                                                      <inlineChoiceInteraction>

                                                                                                                                                      Description: An interaction that allows a single gap in the text to be filled from a set of predefined strings.

                                                                                                                                                      Context:

                                                                                                                                                        See:

                                                                                                                                                        Attributes:

                                                                                                                                                        • id (optional).
                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                        • class (optional).
                                                                                                                                                          Data type = list of styleclass.Type
                                                                                                                                                        • xml:lang (optional).
                                                                                                                                                        • label (optional).
                                                                                                                                                          Data type = string256.Type
                                                                                                                                                        • responseIdentifier (required).
                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                        • shuffle (required).
                                                                                                                                                          Data type = boolean.Type

                                                                                                                                                        Elements:

                                                                                                                                                        inlineInteraction.ElementGroup

                                                                                                                                                        Description: The group of interactions that behave like spans of text.

                                                                                                                                                        Group members: <endAttemptInteraction>, <inlineChoiceInteraction>, <textEntryInteraction>

                                                                                                                                                        Context:

                                                                                                                                                          See:

                                                                                                                                                          inlineStatic.ElementGroup

                                                                                                                                                          Description: A group of elements that behave like spans of text excluding interactions.

                                                                                                                                                          Group members: <a>, <abbr>, <acronym>, <b>, <big>, <br>, <cite>, <code>, <dfn>, <em>, <feedbackInline>, <gap>, <hottext>, <i>, <img>, <kbd>, <m:math>, <object>, <printedVariable>, <q>, <samp>, <small>, <span>, <strong>, <sub>, <sup>, <templateInline>, <tt>, <var>

                                                                                                                                                          Context:

                                                                                                                                                          See:

                                                                                                                                                          <inside>

                                                                                                                                                          Description: An expression for testing if a point is inside a given area.

                                                                                                                                                          Context:

                                                                                                                                                            See:

                                                                                                                                                            Attributes:

                                                                                                                                                            • shape (required).
                                                                                                                                                              Data type = shape.Type
                                                                                                                                                            • coords (required).
                                                                                                                                                              Data type = coords.Type

                                                                                                                                                            Elements:

                                                                                                                                                            integer.Type

                                                                                                                                                            A trivial restriction of xsd:integer.

                                                                                                                                                            <integerDivide>

                                                                                                                                                            Description: An expression for performing integer-division.

                                                                                                                                                            Context:

                                                                                                                                                              See:

                                                                                                                                                              Elements:

                                                                                                                                                              <integerModulus>

                                                                                                                                                              Description: An expression for calculating the remainder following integer-division.

                                                                                                                                                              Context:

                                                                                                                                                                See:

                                                                                                                                                                Elements:

                                                                                                                                                                <integerToFloat>

                                                                                                                                                                Description: An expression for converting an integer to the corresponding value of float base-type.

                                                                                                                                                                Context:

                                                                                                                                                                  See:

                                                                                                                                                                  Elements:

                                                                                                                                                                  interaction.ElementGroup

                                                                                                                                                                  Description: The group of elements that allow the candidate to interact with the item, setting or updating the values of the response variables.

                                                                                                                                                                  Group members: <associateInteraction>, <choiceInteraction>, <customInteraction>, <drawingInteraction>, <endAttemptInteraction>, <extendedTextInteraction>, <gapMatchInteraction>, <graphicAssociateInteraction>, <graphicGapMatchInteraction>, <graphicOrderInteraction>, <hotspotInteraction>, <hottextInteraction>, <inlineChoiceInteraction>, <matchInteraction>, <orderInteraction>, <positionObjectInteraction>, <selectPointInteraction>, <sliderInteraction>, <textEntryInteraction>, <uploadInteraction>

                                                                                                                                                                  Context:

                                                                                                                                                                    Not applicable.

                                                                                                                                                                    <interactionType>

                                                                                                                                                                    Context:

                                                                                                                                                                    Content: a value of type interactionType.Type.

                                                                                                                                                                    interactionType.Type

                                                                                                                                                                    One of the following symbolic values:

                                                                                                                                                                    • associateInteraction
                                                                                                                                                                    • choiceInteraction
                                                                                                                                                                    • customInteraction
                                                                                                                                                                    • drawingInteraction
                                                                                                                                                                    • endAttemptInteraction
                                                                                                                                                                    • extendedTextInteraction
                                                                                                                                                                    • gapMatchInteraction
                                                                                                                                                                    • graphicAssociateInteraction
                                                                                                                                                                    • graphicGapMatchInteraction
                                                                                                                                                                    • graphicOrderInteraction
                                                                                                                                                                    • hotspotInteraction
                                                                                                                                                                    • hottextInteraction
                                                                                                                                                                    • inlineChoiceInteraction
                                                                                                                                                                    • matchInteraction
                                                                                                                                                                    • orderInteraction
                                                                                                                                                                    • positionObjectInteraction
                                                                                                                                                                    • selectPointInteraction
                                                                                                                                                                    • sliderInteraction
                                                                                                                                                                    • textEntryInteraction
                                                                                                                                                                    • uploadInteraction

                                                                                                                                                                    <isNull>

                                                                                                                                                                    Description: An expression that tests for the NULL value.

                                                                                                                                                                    Context:

                                                                                                                                                                      See:

                                                                                                                                                                      Elements:

                                                                                                                                                                      <itemBody>

                                                                                                                                                                      Description: Describes the body of an item, the text, graphics and interactions that are presented to the candidate.

                                                                                                                                                                      Context:

                                                                                                                                                                      Attributes:

                                                                                                                                                                      • id (optional).
                                                                                                                                                                        Data type = identifier.Type
                                                                                                                                                                      • class (optional).
                                                                                                                                                                        Data type = list of styleclass.Type
                                                                                                                                                                      • xml:lang (optional).
                                                                                                                                                                      • label (optional).
                                                                                                                                                                        Data type = string256.Type

                                                                                                                                                                      Elements:

                                                                                                                                                                      itemStatistic.ElementGroup

                                                                                                                                                                      Description: A group of elements used to define item statistics.

                                                                                                                                                                      Group members: <categorizedStatistic>, <ordinaryStatistic>

                                                                                                                                                                      Context:

                                                                                                                                                                      <itemTemplate>

                                                                                                                                                                      Description: A meta-data flag indicating that the item is a template.

                                                                                                                                                                      Context:

                                                                                                                                                                      <kbd>

                                                                                                                                                                      Description: Defined by XHTML

                                                                                                                                                                      Context:

                                                                                                                                                                        See:

                                                                                                                                                                        Attributes:

                                                                                                                                                                        • id (optional).
                                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                                        • class (optional).
                                                                                                                                                                          Data type = list of styleclass.Type
                                                                                                                                                                        • xml:lang (optional).
                                                                                                                                                                        • label (optional).
                                                                                                                                                                          Data type = string256.Type

                                                                                                                                                                        Elements:

                                                                                                                                                                        language.Type

                                                                                                                                                                        A trivial restriction of xsd:string.

                                                                                                                                                                        length.Type

                                                                                                                                                                        A trivial restriction of xsd:string.

                                                                                                                                                                        <li>

                                                                                                                                                                        Description: Defined by XHTML

                                                                                                                                                                        Context:

                                                                                                                                                                        • Occurs [*] within ol
                                                                                                                                                                        • Occurs [*] within ul

                                                                                                                                                                        Attributes:

                                                                                                                                                                        • id (optional).
                                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                                        • class (optional).
                                                                                                                                                                          Data type = list of styleclass.Type
                                                                                                                                                                        • xml:lang (optional).
                                                                                                                                                                        • label (optional).
                                                                                                                                                                          Data type = string256.Type

                                                                                                                                                                        Elements:

                                                                                                                                                                        <listElements>

                                                                                                                                                                        Description: Profile flag for the XHTML list elements.

                                                                                                                                                                        Context:

                                                                                                                                                                        <lomMetadata>

                                                                                                                                                                        Description: Profile flag for LOM meta-data.

                                                                                                                                                                        Context:

                                                                                                                                                                        <lt>

                                                                                                                                                                        Description: An expression for testing the less-than relation between two numbers.

                                                                                                                                                                        Context:

                                                                                                                                                                          See:

                                                                                                                                                                          Elements:

                                                                                                                                                                          <lte>

                                                                                                                                                                          Description: An expression for testing the less-than-or-equal relation between two numbers.

                                                                                                                                                                          Context:

                                                                                                                                                                            See:

                                                                                                                                                                            Elements:

                                                                                                                                                                            <mapEntry>

                                                                                                                                                                            Description: Defines a mapping from a single value, the key, onto a real number.

                                                                                                                                                                            Context:

                                                                                                                                                                            Attributes:

                                                                                                                                                                            • mapKey (required).
                                                                                                                                                                              Data type = xsd:string
                                                                                                                                                                            • mappedValue (required).
                                                                                                                                                                              Data type = float.Type

                                                                                                                                                                            <mapResponse>

                                                                                                                                                                            Description: An expression for mapping the value(s) of a response variable onto a real number using the declared mapping.

                                                                                                                                                                            Context:

                                                                                                                                                                              See:

                                                                                                                                                                              Attributes:

                                                                                                                                                                              • identifier (required).
                                                                                                                                                                                Data type = identifier.Type

                                                                                                                                                                              <mapResponsePoint>

                                                                                                                                                                              Description: An expression for mapping the value(s) of a point-type response variable onto a real number using the declared area-mapping.

                                                                                                                                                                              Context:

                                                                                                                                                                                See:

                                                                                                                                                                                Attributes:

                                                                                                                                                                                • identifier (required).
                                                                                                                                                                                  Data type = identifier.Type

                                                                                                                                                                                <mapping>

                                                                                                                                                                                Description: Defines a mapping from a source set of values onto real numbers.

                                                                                                                                                                                Context:

                                                                                                                                                                                Attributes:

                                                                                                                                                                                • lowerBound (optional).
                                                                                                                                                                                  Data type = float.Type
                                                                                                                                                                                • upperBound (optional).
                                                                                                                                                                                  Data type = float.Type
                                                                                                                                                                                • defaultValue (required).
                                                                                                                                                                                  Data type = float.Type

                                                                                                                                                                                Elements:

                                                                                                                                                                                <match>

                                                                                                                                                                                Description: An expression for testing if two values are identical.

                                                                                                                                                                                Context:

                                                                                                                                                                                  See:

                                                                                                                                                                                  Elements:

                                                                                                                                                                                  <matchInteraction>

                                                                                                                                                                                  Description: Interaction in which the candidate must identify pairs of choices between two distinct sets.

                                                                                                                                                                                  Context:

                                                                                                                                                                                    See:

                                                                                                                                                                                    Attributes:

                                                                                                                                                                                    • id (optional).
                                                                                                                                                                                      Data type = identifier.Type
                                                                                                                                                                                    • class (optional).
                                                                                                                                                                                      Data type = list of styleclass.Type
                                                                                                                                                                                    • xml:lang (optional).
                                                                                                                                                                                    • label (optional).
                                                                                                                                                                                      Data type = string256.Type
                                                                                                                                                                                    • responseIdentifier (required).
                                                                                                                                                                                      Data type = identifier.Type
                                                                                                                                                                                    • shuffle (required).
                                                                                                                                                                                      Data type = boolean.Type
                                                                                                                                                                                    • maxAssociations (required).
                                                                                                                                                                                      Data type = integer.Type

                                                                                                                                                                                    Elements:

                                                                                                                                                                                    <m:math>

                                                                                                                                                                                    Externally defined.

                                                                                                                                                                                    <mathElement>

                                                                                                                                                                                    Description: Profile flag for the MathML math element.

                                                                                                                                                                                    Context:

                                                                                                                                                                                    <mathVariable>

                                                                                                                                                                                    Description: Profile flag for the mathVariable feature.

                                                                                                                                                                                    Context:

                                                                                                                                                                                    <member>

                                                                                                                                                                                    Description: An expression that tests a container to determine if it contains a given value.

                                                                                                                                                                                    Context:

                                                                                                                                                                                      See:

                                                                                                                                                                                      Elements:

                                                                                                                                                                                      <metadataProfile>

                                                                                                                                                                                      Description: An element for describing the capabilities or requirements of a system with respect to meta-data.

                                                                                                                                                                                      Context:

                                                                                                                                                                                      Elements:

                                                                                                                                                                                      mimeType.Type

                                                                                                                                                                                      A trivial restriction of xsd:string.

                                                                                                                                                                                      <modalFeedback>

                                                                                                                                                                                      Description: Feedback conditionally shown to the candidate directly following response processing depending on the value of the given outcome variable.

                                                                                                                                                                                      Context:

                                                                                                                                                                                      Attributes:

                                                                                                                                                                                      • outcomeIdentifier (required).
                                                                                                                                                                                        Data type = identifier.Type
                                                                                                                                                                                      • showHide (required).
                                                                                                                                                                                        Data type = showHide.Type
                                                                                                                                                                                      • identifier (required).
                                                                                                                                                                                        Data type = identifier.Type
                                                                                                                                                                                      • title (optional).
                                                                                                                                                                                        Data type = string.Type

                                                                                                                                                                                      Elements:

                                                                                                                                                                                      <multiple>

                                                                                                                                                                                      Description: An expression that aggregates sub-expressions into a single unordered container.

                                                                                                                                                                                      Context:

                                                                                                                                                                                        See:

                                                                                                                                                                                        Elements:

                                                                                                                                                                                        <not>

                                                                                                                                                                                        Description: An expression that performs boolean negation.

                                                                                                                                                                                        Context:

                                                                                                                                                                                          See:

                                                                                                                                                                                          Elements:

                                                                                                                                                                                          <null>

                                                                                                                                                                                          Description: A simple expression that returns the NULL value.

                                                                                                                                                                                          Context:

                                                                                                                                                                                            See:

                                                                                                                                                                                            <object>

                                                                                                                                                                                            Description: Defined by XHTML

                                                                                                                                                                                            Context:

                                                                                                                                                                                            See:

                                                                                                                                                                                            Attributes:

                                                                                                                                                                                            • id (optional).
                                                                                                                                                                                              Data type = identifier.Type
                                                                                                                                                                                            • class (optional).
                                                                                                                                                                                              Data type = list of styleclass.Type
                                                                                                                                                                                            • xml:lang (optional).
                                                                                                                                                                                            • label (optional).
                                                                                                                                                                                              Data type = string256.Type
                                                                                                                                                                                            • data (required).
                                                                                                                                                                                              Data type = string.Type
                                                                                                                                                                                            • type (required).
                                                                                                                                                                                              Data type = mimeType.Type
                                                                                                                                                                                            • width (optional).
                                                                                                                                                                                              Data type = length.Type
                                                                                                                                                                                            • height (optional).
                                                                                                                                                                                              Data type = length.Type

                                                                                                                                                                                            Elements:

                                                                                                                                                                                            <objectElements>

                                                                                                                                                                                            Description: Profile flag for the XHTML object element.

                                                                                                                                                                                            Context:

                                                                                                                                                                                            objectFlow.ElementGroup

                                                                                                                                                                                            Description: The group of elements that can appear within <object>.

                                                                                                                                                                                            Group members: <a>, <abbr>, <acronym>, <address>, <associateInteraction>, <b>, <big>, <blockquote>, <br>, <choiceInteraction>, <cite>, <code>, <customInteraction>, <dfn>, <div>, <dl>, <drawingInteraction>, <em>, <endAttemptInteraction>, <extendedTextInteraction>, <feedbackBlock>, <feedbackInline>, <gapMatchInteraction>, <graphicAssociateInteraction>, <graphicGapMatchInteraction>, <graphicOrderInteraction>, <h1>, <h2>, <h3>, <h4>, <h5>, <h6>, <hotspotInteraction>, <hottext>, <hottextInteraction>, <hr>, <i>, <img>, <inlineChoiceInteraction>, <kbd>, <m:math>, <matchInteraction>, <object>, <ol>, <orderInteraction>, <p>, <param>, <pre>, <printedVariable>, <q>, <rubricBlock>, <samp>, <selectPointInteraction>, <sliderInteraction>, <small>, <span>, <strong>, <sub>, <sup>, <table>, <templateBlock>, <templateInline>, <textEntryInteraction>, <tt>, <ul>, <uploadInteraction>, <var>

                                                                                                                                                                                            Context:

                                                                                                                                                                                            <objectType>

                                                                                                                                                                                            Description: Profile element for identifying a specific object mime-type.

                                                                                                                                                                                            Context:

                                                                                                                                                                                            <ol>

                                                                                                                                                                                            Description: Defined by XHTML

                                                                                                                                                                                            Context:

                                                                                                                                                                                              See:

                                                                                                                                                                                              Attributes:

                                                                                                                                                                                              • id (optional).
                                                                                                                                                                                                Data type = identifier.Type
                                                                                                                                                                                              • class (optional).
                                                                                                                                                                                                Data type = list of styleclass.Type
                                                                                                                                                                                              • xml:lang (optional).
                                                                                                                                                                                              • label (optional).
                                                                                                                                                                                                Data type = string256.Type

                                                                                                                                                                                              Elements:

                                                                                                                                                                                              <or>

                                                                                                                                                                                              Description: An expression that performs a boolean or.

                                                                                                                                                                                              Context:

                                                                                                                                                                                                See:

                                                                                                                                                                                                Elements:

                                                                                                                                                                                                <orderInteraction>

                                                                                                                                                                                                Description: Interaction in which candidates must (re-)order a set of choices

                                                                                                                                                                                                Context:

                                                                                                                                                                                                  See:

                                                                                                                                                                                                  Attributes:

                                                                                                                                                                                                  • id (optional).
                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                  • class (optional).
                                                                                                                                                                                                    Data type = list of styleclass.Type
                                                                                                                                                                                                  • xml:lang (optional).
                                                                                                                                                                                                  • label (optional).
                                                                                                                                                                                                    Data type = string256.Type
                                                                                                                                                                                                  • responseIdentifier (required).
                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                  • shuffle (required).
                                                                                                                                                                                                    Data type = boolean.Type
                                                                                                                                                                                                  • orientation (optional).
                                                                                                                                                                                                    Data type = orientation.Type

                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                  <ordered>

                                                                                                                                                                                                  Description: An expression that aggregates sub-expressions into a single ordered container.

                                                                                                                                                                                                  Context:

                                                                                                                                                                                                    See:

                                                                                                                                                                                                    Elements:

                                                                                                                                                                                                    <ordinaryStatistic>

                                                                                                                                                                                                    Description: An ordinary single-valued item statistic.

                                                                                                                                                                                                    Context:

                                                                                                                                                                                                      See:

                                                                                                                                                                                                      Attributes:

                                                                                                                                                                                                      • name (required).
                                                                                                                                                                                                        Data type = identifier.Type
                                                                                                                                                                                                      • glossary (optional).
                                                                                                                                                                                                        Data type = uri.Type
                                                                                                                                                                                                      • context (required).
                                                                                                                                                                                                        Data type = uri.Type
                                                                                                                                                                                                      • caseCount (optional).
                                                                                                                                                                                                        Data type = integer.Type
                                                                                                                                                                                                      • stdError (optional).
                                                                                                                                                                                                        Data type = float.Type
                                                                                                                                                                                                      • stdDeviation (optional).
                                                                                                                                                                                                        Data type = float.Type
                                                                                                                                                                                                      • lastUpdated (optional).
                                                                                                                                                                                                        Data type = date.Type

                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                      orientation.Type

                                                                                                                                                                                                      One of the following symbolic values:

                                                                                                                                                                                                      • horizontal
                                                                                                                                                                                                      • vertical

                                                                                                                                                                                                      <outcomeDeclaration>

                                                                                                                                                                                                      Description: Declares an outcome variable.

                                                                                                                                                                                                      Context:

                                                                                                                                                                                                      Attributes:

                                                                                                                                                                                                      • identifier (required).
                                                                                                                                                                                                        Data type = identifier.Type
                                                                                                                                                                                                      • cardinality (required).
                                                                                                                                                                                                        Data type = cardinality.Type
                                                                                                                                                                                                      • baseType (optional).
                                                                                                                                                                                                        Data type = baseType.Type
                                                                                                                                                                                                      • interpretation (optional).
                                                                                                                                                                                                        Data type = string.Type
                                                                                                                                                                                                      • longInterpretation (optional).
                                                                                                                                                                                                        Data type = uri.Type
                                                                                                                                                                                                      • normalMaximum (optional).
                                                                                                                                                                                                        Data type = float.Type

                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                      <p>

                                                                                                                                                                                                      Description: Defined by XHTML

                                                                                                                                                                                                      Context:

                                                                                                                                                                                                        See:

                                                                                                                                                                                                        Attributes:

                                                                                                                                                                                                        • id (optional).
                                                                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                                                                        • class (optional).
                                                                                                                                                                                                          Data type = list of styleclass.Type
                                                                                                                                                                                                        • xml:lang (optional).
                                                                                                                                                                                                        • label (optional).
                                                                                                                                                                                                          Data type = string256.Type

                                                                                                                                                                                                        Elements:

                                                                                                                                                                                                        <param>

                                                                                                                                                                                                        Description: Defined by XHTML

                                                                                                                                                                                                        Context:

                                                                                                                                                                                                          See:

                                                                                                                                                                                                          Attributes:

                                                                                                                                                                                                          • name (required).
                                                                                                                                                                                                            Data type = string.Type
                                                                                                                                                                                                          • value (required).
                                                                                                                                                                                                            Data type = string.Type
                                                                                                                                                                                                          • valuetype (required).
                                                                                                                                                                                                            Data type = paramType.Type
                                                                                                                                                                                                          • type (optional).
                                                                                                                                                                                                            Data type = mimeType.Type

                                                                                                                                                                                                          paramType.Type

                                                                                                                                                                                                          One of the following symbolic values:

                                                                                                                                                                                                          • DATA
                                                                                                                                                                                                          • REF

                                                                                                                                                                                                          <patternMatch>

                                                                                                                                                                                                          Description: An expression for testing two string values using regular expressions.

                                                                                                                                                                                                          Context:

                                                                                                                                                                                                            See:

                                                                                                                                                                                                            Attributes:

                                                                                                                                                                                                            • pattern (required).
                                                                                                                                                                                                              Data type = string.Type

                                                                                                                                                                                                            Elements:

                                                                                                                                                                                                            <positionObjectInteraction>

                                                                                                                                                                                                            Description: Interaction in which the candidate must position objects over an existing image.

                                                                                                                                                                                                            Context:

                                                                                                                                                                                                            Attributes:

                                                                                                                                                                                                            • id (optional).
                                                                                                                                                                                                              Data type = identifier.Type
                                                                                                                                                                                                            • class (optional).
                                                                                                                                                                                                              Data type = list of styleclass.Type
                                                                                                                                                                                                            • xml:lang (optional).
                                                                                                                                                                                                            • label (optional).
                                                                                                                                                                                                              Data type = string256.Type
                                                                                                                                                                                                            • responseIdentifier (required).
                                                                                                                                                                                                              Data type = identifier.Type
                                                                                                                                                                                                            • centerPoint (optional).
                                                                                                                                                                                                              Data type = list of integer.Type
                                                                                                                                                                                                            • maxChoices (required).
                                                                                                                                                                                                              Data type = integer.Type

                                                                                                                                                                                                            Elements:

                                                                                                                                                                                                            <positionObjectStage>

                                                                                                                                                                                                            Description: Defines the background image to be used for positioning object tasks.

                                                                                                                                                                                                            Context:

                                                                                                                                                                                                              See:

                                                                                                                                                                                                              Elements:

                                                                                                                                                                                                              <power>

                                                                                                                                                                                                              Description: An expression for raising one number to the power of another.

                                                                                                                                                                                                              Context:

                                                                                                                                                                                                                See:

                                                                                                                                                                                                                Elements:

                                                                                                                                                                                                                <pre>

                                                                                                                                                                                                                Description: Defined by XHTML

                                                                                                                                                                                                                Context:

                                                                                                                                                                                                                  See:

                                                                                                                                                                                                                  Attributes:

                                                                                                                                                                                                                  • id (optional).
                                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                                  • class (optional).
                                                                                                                                                                                                                    Data type = list of styleclass.Type
                                                                                                                                                                                                                  • xml:lang (optional).
                                                                                                                                                                                                                  • label (optional).
                                                                                                                                                                                                                    Data type = string256.Type

                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                  <presentationElements>

                                                                                                                                                                                                                  Description: Profile flag for the XHTML presentation elements.

                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                  <printedVariable>

                                                                                                                                                                                                                  Description: An element used to insert the value of an item variable into the item body.

                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                    See:

                                                                                                                                                                                                                    Attributes:

                                                                                                                                                                                                                    • id (optional).
                                                                                                                                                                                                                      Data type = identifier.Type
                                                                                                                                                                                                                    • class (optional).
                                                                                                                                                                                                                      Data type = list of styleclass.Type
                                                                                                                                                                                                                    • xml:lang (optional).
                                                                                                                                                                                                                    • label (optional).
                                                                                                                                                                                                                      Data type = string256.Type
                                                                                                                                                                                                                    • identifier (required).
                                                                                                                                                                                                                      Data type = identifier.Type
                                                                                                                                                                                                                    • format (optional).
                                                                                                                                                                                                                      Data type = string256.Type
                                                                                                                                                                                                                    • base (optional).
                                                                                                                                                                                                                      Data type = integer.Type

                                                                                                                                                                                                                    <printedVariables>

                                                                                                                                                                                                                    Description: Profile flag for the printedVariable feature.

                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                    <product>

                                                                                                                                                                                                                    Description: An expression for calculating the product of a group of numbers.

                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                      See:

                                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                                      <prompt>

                                                                                                                                                                                                                      Description: An optional prompt for an interaction.

                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                      Attributes:

                                                                                                                                                                                                                      • id (optional).
                                                                                                                                                                                                                        Data type = identifier.Type
                                                                                                                                                                                                                      • class (optional).
                                                                                                                                                                                                                        Data type = list of styleclass.Type
                                                                                                                                                                                                                      • xml:lang (optional).
                                                                                                                                                                                                                      • label (optional).
                                                                                                                                                                                                                        Data type = string256.Type

                                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                                      <q>

                                                                                                                                                                                                                      Description: Defined by XHTML

                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                        See:

                                                                                                                                                                                                                        Attributes:

                                                                                                                                                                                                                        • id (optional).
                                                                                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                                                                                        • class (optional).
                                                                                                                                                                                                                          Data type = list of styleclass.Type
                                                                                                                                                                                                                        • xml:lang (optional).
                                                                                                                                                                                                                        • label (optional).
                                                                                                                                                                                                                          Data type = string256.Type
                                                                                                                                                                                                                        • cite (optional).
                                                                                                                                                                                                                          Data type = uri.Type

                                                                                                                                                                                                                        Elements:

                                                                                                                                                                                                                        <qtiMetadata>

                                                                                                                                                                                                                        Description: The root element for QTI-specific meta-data. Typically used within a manifest file in an IMS content package.

                                                                                                                                                                                                                        Context:

                                                                                                                                                                                                                          Can be the root element of an XML document.

                                                                                                                                                                                                                          Elements:

                                                                                                                                                                                                                          <random>

                                                                                                                                                                                                                          Description: An expression that extracts a random value from a container.

                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                            See:

                                                                                                                                                                                                                            Elements:

                                                                                                                                                                                                                            <randomFloat>

                                                                                                                                                                                                                            Description: An expression that returns a random float from the specified range.

                                                                                                                                                                                                                            Context:

                                                                                                                                                                                                                              See:

                                                                                                                                                                                                                              Attributes:

                                                                                                                                                                                                                              • min (required).
                                                                                                                                                                                                                                Data type = float.Type
                                                                                                                                                                                                                              • max (required).
                                                                                                                                                                                                                                Data type = float.Type

                                                                                                                                                                                                                              <randomInteger>

                                                                                                                                                                                                                              Description: An expression that returns a random integer from the specified range.

                                                                                                                                                                                                                              Context:

                                                                                                                                                                                                                                See:

                                                                                                                                                                                                                                Attributes:

                                                                                                                                                                                                                                • min (required).
                                                                                                                                                                                                                                  Data type = integer.Type
                                                                                                                                                                                                                                • max (required).
                                                                                                                                                                                                                                  Data type = integer.Type
                                                                                                                                                                                                                                • step (optional).
                                                                                                                                                                                                                                  Data type = integer.Type

                                                                                                                                                                                                                                <regexp>

                                                                                                                                                                                                                                Description: Profile flag for the regular-expression feature.

                                                                                                                                                                                                                                Context:

                                                                                                                                                                                                                                <responseCondition>

                                                                                                                                                                                                                                Description: A response rule that contains groups of sub-rules which are followed conditionally based on the value of one or more expressions.

                                                                                                                                                                                                                                Context:

                                                                                                                                                                                                                                  See:

                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                  <responseDeclaration>

                                                                                                                                                                                                                                  Description: Declares a response variable.

                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                  Attributes:

                                                                                                                                                                                                                                  • identifier (required).
                                                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                                                  • cardinality (required).
                                                                                                                                                                                                                                    Data type = cardinality.Type
                                                                                                                                                                                                                                  • baseType (optional).
                                                                                                                                                                                                                                    Data type = baseType.Type

                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                  <responseElse>

                                                                                                                                                                                                                                  Description: A final group of rules to be followed unconditionally if all previous groups have been skipped for the containing response condition.

                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                  <responseElseIf>

                                                                                                                                                                                                                                  Description: A conditional group of rules to be considered if all previous groups have been skipped for the containing response condition.

                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                  <responseIf>

                                                                                                                                                                                                                                  Description: The first part of a response condition.

                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                  <responseProcessing>

                                                                                                                                                                                                                                  Description: Defines the rules used to process the candidate's responses.

                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                  Can be the root element of an XML document.

                                                                                                                                                                                                                                  Attributes:

                                                                                                                                                                                                                                  • template (optional).
                                                                                                                                                                                                                                    Data type = uri.Type
                                                                                                                                                                                                                                  • templateLocation (optional).
                                                                                                                                                                                                                                    Data type = uri.Type

                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                  responseRule.ElementGroup

                                                                                                                                                                                                                                  Description: A group of elements that define rules to be followed during response processing.

                                                                                                                                                                                                                                  Group members: <exitResponse>, <responseCondition>, <setOutcomeValue>

                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                  <responseRules>

                                                                                                                                                                                                                                  Description: Profile flag for the general response processing feature.

                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                  <round>

                                                                                                                                                                                                                                  Description: An expression for rounding a real number to an integer.

                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                    See:

                                                                                                                                                                                                                                    Elements:

                                                                                                                                                                                                                                    <rounding>

                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                    roundingMode.Type

                                                                                                                                                                                                                                    One of the following symbolic values:

                                                                                                                                                                                                                                    • decimalPlaces
                                                                                                                                                                                                                                    • significantFigures

                                                                                                                                                                                                                                    <rpTemplate>

                                                                                                                                                                                                                                    Description: Profile element for identifying a specific response processing template.

                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                    <rubric>

                                                                                                                                                                                                                                    Description: Profile flag for the rubric feature.

                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                    <rubricBlock>

                                                                                                                                                                                                                                    Description: A structural part of the item body whose visibility depends on the role of the person viewing the item, typically containing instructions to a specific actor.

                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                      See:

                                                                                                                                                                                                                                      Attributes:

                                                                                                                                                                                                                                      • id (optional).
                                                                                                                                                                                                                                        Data type = identifier.Type
                                                                                                                                                                                                                                      • class (optional).
                                                                                                                                                                                                                                        Data type = list of styleclass.Type
                                                                                                                                                                                                                                      • xml:lang (optional).
                                                                                                                                                                                                                                      • label (optional).
                                                                                                                                                                                                                                        Data type = string256.Type
                                                                                                                                                                                                                                      • view (required).
                                                                                                                                                                                                                                        Data type = list of view.Type

                                                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                                                      <samp>

                                                                                                                                                                                                                                      Description: Defined by XHTML

                                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                                        See:

                                                                                                                                                                                                                                        Attributes:

                                                                                                                                                                                                                                        • id (optional).
                                                                                                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                                                                                                        • class (optional).
                                                                                                                                                                                                                                          Data type = list of styleclass.Type
                                                                                                                                                                                                                                        • xml:lang (optional).
                                                                                                                                                                                                                                        • label (optional).
                                                                                                                                                                                                                                          Data type = string256.Type

                                                                                                                                                                                                                                        Elements:

                                                                                                                                                                                                                                        <selectPointInteraction>

                                                                                                                                                                                                                                        Description: Interaction in which the candidate selects one or more points on an image.

                                                                                                                                                                                                                                        Context:

                                                                                                                                                                                                                                          See:

                                                                                                                                                                                                                                          Attributes:

                                                                                                                                                                                                                                          • id (optional).
                                                                                                                                                                                                                                            Data type = identifier.Type
                                                                                                                                                                                                                                          • class (optional).
                                                                                                                                                                                                                                            Data type = list of styleclass.Type
                                                                                                                                                                                                                                          • xml:lang (optional).
                                                                                                                                                                                                                                          • label (optional).
                                                                                                                                                                                                                                            Data type = string256.Type
                                                                                                                                                                                                                                          • responseIdentifier (required).
                                                                                                                                                                                                                                            Data type = identifier.Type
                                                                                                                                                                                                                                          • maxChoices (required).
                                                                                                                                                                                                                                            Data type = integer.Type

                                                                                                                                                                                                                                          Elements:

                                                                                                                                                                                                                                          <setCorrectResponse>

                                                                                                                                                                                                                                          Description: A template rule that sets the correct value of a response variable.

                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                            See:

                                                                                                                                                                                                                                            Attributes:

                                                                                                                                                                                                                                            • identifier (required).
                                                                                                                                                                                                                                              Data type = identifier.Type

                                                                                                                                                                                                                                            Elements:

                                                                                                                                                                                                                                            <setDefaultValue>

                                                                                                                                                                                                                                            Description: A template rule that sets the default value of an item variable.

                                                                                                                                                                                                                                            Context:

                                                                                                                                                                                                                                              See:

                                                                                                                                                                                                                                              Attributes:

                                                                                                                                                                                                                                              • identifier (required).
                                                                                                                                                                                                                                                Data type = identifier.Type

                                                                                                                                                                                                                                              Elements:

                                                                                                                                                                                                                                              <setOutcomeValue>

                                                                                                                                                                                                                                              Description: A response rule that sets the value of an outcome variable.

                                                                                                                                                                                                                                              Context:

                                                                                                                                                                                                                                                See:

                                                                                                                                                                                                                                                Attributes:

                                                                                                                                                                                                                                                • identifier (required).
                                                                                                                                                                                                                                                  Data type = identifier.Type

                                                                                                                                                                                                                                                Elements:

                                                                                                                                                                                                                                                <setTemplateValue>

                                                                                                                                                                                                                                                Description: A template rule that sets the value of a template variable.

                                                                                                                                                                                                                                                Context:

                                                                                                                                                                                                                                                  See:

                                                                                                                                                                                                                                                  Attributes:

                                                                                                                                                                                                                                                  • identifier (required).
                                                                                                                                                                                                                                                    Data type = identifier.Type

                                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                                  shape.Type

                                                                                                                                                                                                                                                  One of the following symbolic values:

                                                                                                                                                                                                                                                  • circle
                                                                                                                                                                                                                                                  • default
                                                                                                                                                                                                                                                  • ellipse
                                                                                                                                                                                                                                                  • poly
                                                                                                                                                                                                                                                  • rect

                                                                                                                                                                                                                                                  showHide.Type

                                                                                                                                                                                                                                                  One of the following symbolic values:

                                                                                                                                                                                                                                                  • hide
                                                                                                                                                                                                                                                  • show

                                                                                                                                                                                                                                                  sign.Type

                                                                                                                                                                                                                                                  A trivial restriction of xsd:string.

                                                                                                                                                                                                                                                  <simpleAssociableChoice>

                                                                                                                                                                                                                                                  Description: The element used to describe the choices in simple association or matching tasks.

                                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                                  Attributes:

                                                                                                                                                                                                                                                  • id (optional).
                                                                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                                                                  • class (optional).
                                                                                                                                                                                                                                                    Data type = list of styleclass.Type
                                                                                                                                                                                                                                                  • xml:lang (optional).
                                                                                                                                                                                                                                                  • label (optional).
                                                                                                                                                                                                                                                    Data type = string256.Type
                                                                                                                                                                                                                                                  • identifier (required).
                                                                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                                                                  • fixed (optional).
                                                                                                                                                                                                                                                    Data type = boolean.Type
                                                                                                                                                                                                                                                  • matchGroup (optional).
                                                                                                                                                                                                                                                    Data type = list of identifier.Type
                                                                                                                                                                                                                                                  • matchMax (required).
                                                                                                                                                                                                                                                    Data type = integer.Type

                                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                                  simpleBlock.ElementGroup

                                                                                                                                                                                                                                                  Description: A group of elements that provide simple aggregating structure to the item body.

                                                                                                                                                                                                                                                  Group members: <blockquote>, <feedbackBlock>, <rubricBlock>

                                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                                    See:

                                                                                                                                                                                                                                                    <simpleChoice>

                                                                                                                                                                                                                                                    Description: The element used to describe the choices in simple selection or ordering tasks.

                                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                                    Attributes:

                                                                                                                                                                                                                                                    • id (optional).
                                                                                                                                                                                                                                                      Data type = identifier.Type
                                                                                                                                                                                                                                                    • class (optional).
                                                                                                                                                                                                                                                      Data type = list of styleclass.Type
                                                                                                                                                                                                                                                    • xml:lang (optional).
                                                                                                                                                                                                                                                    • label (optional).
                                                                                                                                                                                                                                                      Data type = string256.Type
                                                                                                                                                                                                                                                    • identifier (required).
                                                                                                                                                                                                                                                      Data type = identifier.Type
                                                                                                                                                                                                                                                    • fixed (optional).
                                                                                                                                                                                                                                                      Data type = boolean.Type

                                                                                                                                                                                                                                                    Elements:

                                                                                                                                                                                                                                                    simpleInline.ElementGroup

                                                                                                                                                                                                                                                    Description: A group of elements that both behave as and contain things that behave like spans of text.

                                                                                                                                                                                                                                                    Group members: <a>, <abbr>, <acronym>, <b>, <big>, <cite>, <code>, <dfn>, <em>, <feedbackInline>, <i>, <kbd>, <q>, <samp>, <small>, <span>, <strong>, <sub>, <sup>, <tt>, <var>

                                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                                      See:

                                                                                                                                                                                                                                                      <simpleMatchSet>

                                                                                                                                                                                                                                                      Description: Describes a set of choices for use in a matching task.

                                                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                                                                      <sliderInteraction>

                                                                                                                                                                                                                                                      Description: Interaction in which the candidate uses a slider to enter a constrained numeric response.

                                                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                                                        See:

                                                                                                                                                                                                                                                        Attributes:

                                                                                                                                                                                                                                                        • id (optional).
                                                                                                                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                                                                                                                        • class (optional).
                                                                                                                                                                                                                                                          Data type = list of styleclass.Type
                                                                                                                                                                                                                                                        • xml:lang (optional).
                                                                                                                                                                                                                                                        • label (optional).
                                                                                                                                                                                                                                                          Data type = string256.Type
                                                                                                                                                                                                                                                        • responseIdentifier (required).
                                                                                                                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                                                                                                                        • lowerBound (required).
                                                                                                                                                                                                                                                          Data type = float.Type
                                                                                                                                                                                                                                                        • upperBound (required).
                                                                                                                                                                                                                                                          Data type = float.Type
                                                                                                                                                                                                                                                        • step (optional).
                                                                                                                                                                                                                                                          Data type = integer.Type
                                                                                                                                                                                                                                                        • stepLabel (optional).
                                                                                                                                                                                                                                                          Data type = boolean.Type
                                                                                                                                                                                                                                                        • orientation (optional).
                                                                                                                                                                                                                                                          Data type = orientation.Type
                                                                                                                                                                                                                                                        • reverse (optional).
                                                                                                                                                                                                                                                          Data type = boolean.Type

                                                                                                                                                                                                                                                        Elements:

                                                                                                                                                                                                                                                        <small>

                                                                                                                                                                                                                                                        Description: Defined by XHTML

                                                                                                                                                                                                                                                        Context:

                                                                                                                                                                                                                                                          See:

                                                                                                                                                                                                                                                          Attributes:

                                                                                                                                                                                                                                                          • id (optional).
                                                                                                                                                                                                                                                            Data type = identifier.Type
                                                                                                                                                                                                                                                          • class (optional).
                                                                                                                                                                                                                                                            Data type = list of styleclass.Type
                                                                                                                                                                                                                                                          • xml:lang (optional).
                                                                                                                                                                                                                                                          • label (optional).
                                                                                                                                                                                                                                                            Data type = string256.Type

                                                                                                                                                                                                                                                          Elements:

                                                                                                                                                                                                                                                          <solutionAvailable>

                                                                                                                                                                                                                                                          Description: A meta-data flag indicating that the item contains a solution.

                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                          <span>

                                                                                                                                                                                                                                                          Description: Defined by XHTML

                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                            See:

                                                                                                                                                                                                                                                            Attributes:

                                                                                                                                                                                                                                                            • id (optional).
                                                                                                                                                                                                                                                              Data type = identifier.Type
                                                                                                                                                                                                                                                            • class (optional).
                                                                                                                                                                                                                                                              Data type = list of styleclass.Type
                                                                                                                                                                                                                                                            • xml:lang (optional).
                                                                                                                                                                                                                                                            • label (optional).
                                                                                                                                                                                                                                                              Data type = string256.Type

                                                                                                                                                                                                                                                            Elements:

                                                                                                                                                                                                                                                            string.Type

                                                                                                                                                                                                                                                            A trivial restriction of xsd:string.

                                                                                                                                                                                                                                                            string256.Type

                                                                                                                                                                                                                                                            A trivial restriction of xsd:string.

                                                                                                                                                                                                                                                            stringInteraction.ElementGroup

                                                                                                                                                                                                                                                            Description: A group of interactions that allow text-based responses to be entered by the user.

                                                                                                                                                                                                                                                            Group members: <extendedTextInteraction>, <textEntryInteraction>

                                                                                                                                                                                                                                                            Context:

                                                                                                                                                                                                                                                              Not applicable.

                                                                                                                                                                                                                                                              <stringMatch>

                                                                                                                                                                                                                                                              Description: An expression for testing two string values.

                                                                                                                                                                                                                                                              Context:

                                                                                                                                                                                                                                                                See:

                                                                                                                                                                                                                                                                Attributes:

                                                                                                                                                                                                                                                                • caseSensitive (required).
                                                                                                                                                                                                                                                                  Data type = boolean.Type
                                                                                                                                                                                                                                                                • substring (required).
                                                                                                                                                                                                                                                                  Data type = boolean.Type

                                                                                                                                                                                                                                                                Elements:

                                                                                                                                                                                                                                                                <strong>

                                                                                                                                                                                                                                                                Description: Defined by XHTML

                                                                                                                                                                                                                                                                Context:

                                                                                                                                                                                                                                                                  See:

                                                                                                                                                                                                                                                                  Attributes:

                                                                                                                                                                                                                                                                  • id (optional).
                                                                                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                                                                                  • class (optional).
                                                                                                                                                                                                                                                                    Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                  • xml:lang (optional).
                                                                                                                                                                                                                                                                  • label (optional).
                                                                                                                                                                                                                                                                    Data type = string256.Type

                                                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                                                  styleclass.Type

                                                                                                                                                                                                                                                                  A trivial restriction of xsd:string.

                                                                                                                                                                                                                                                                  <stylesheet>

                                                                                                                                                                                                                                                                  Description: Associates a stylesheet with an item.

                                                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                                                  Attributes:

                                                                                                                                                                                                                                                                  • href (required).
                                                                                                                                                                                                                                                                    Data type = uri.Type
                                                                                                                                                                                                                                                                  • type (required).
                                                                                                                                                                                                                                                                    Data type = mimeType.Type
                                                                                                                                                                                                                                                                  • media (optional).
                                                                                                                                                                                                                                                                    Data type = string.Type
                                                                                                                                                                                                                                                                  • title (optional).
                                                                                                                                                                                                                                                                    Data type = string.Type

                                                                                                                                                                                                                                                                  <sub>

                                                                                                                                                                                                                                                                  Description: Defined by XHTML

                                                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                                                    See:

                                                                                                                                                                                                                                                                    Attributes:

                                                                                                                                                                                                                                                                    • id (optional).
                                                                                                                                                                                                                                                                      Data type = identifier.Type
                                                                                                                                                                                                                                                                    • class (optional).
                                                                                                                                                                                                                                                                      Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                    • xml:lang (optional).
                                                                                                                                                                                                                                                                    • label (optional).
                                                                                                                                                                                                                                                                      Data type = string256.Type

                                                                                                                                                                                                                                                                    Elements:

                                                                                                                                                                                                                                                                    <substring>

                                                                                                                                                                                                                                                                    Description: An expression that tests a string to determine if it contains another.

                                                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                                                      See:

                                                                                                                                                                                                                                                                      Attributes:

                                                                                                                                                                                                                                                                      • caseSensitive (required).
                                                                                                                                                                                                                                                                        Data type = boolean.Type

                                                                                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                                                                                      <subtract>

                                                                                                                                                                                                                                                                      Description: An expression for subtracting one number from another.

                                                                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                                                                        See:

                                                                                                                                                                                                                                                                        Elements:

                                                                                                                                                                                                                                                                        <sum>

                                                                                                                                                                                                                                                                        Description: An expression for calculating the sum of a group of numbers.

                                                                                                                                                                                                                                                                        Context:

                                                                                                                                                                                                                                                                          See:

                                                                                                                                                                                                                                                                          Elements:

                                                                                                                                                                                                                                                                          <sup>

                                                                                                                                                                                                                                                                          Description: Defined by XHTML

                                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                                            See:

                                                                                                                                                                                                                                                                            Attributes:

                                                                                                                                                                                                                                                                            • id (optional).
                                                                                                                                                                                                                                                                              Data type = identifier.Type
                                                                                                                                                                                                                                                                            • class (optional).
                                                                                                                                                                                                                                                                              Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                            • xml:lang (optional).
                                                                                                                                                                                                                                                                            • label (optional).
                                                                                                                                                                                                                                                                              Data type = string256.Type

                                                                                                                                                                                                                                                                            Elements:

                                                                                                                                                                                                                                                                            <table>

                                                                                                                                                                                                                                                                            Description: Defined by XHTML

                                                                                                                                                                                                                                                                            Context:

                                                                                                                                                                                                                                                                              See:

                                                                                                                                                                                                                                                                              Attributes:

                                                                                                                                                                                                                                                                              • id (optional).
                                                                                                                                                                                                                                                                                Data type = identifier.Type
                                                                                                                                                                                                                                                                              • class (optional).
                                                                                                                                                                                                                                                                                Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                              • xml:lang (optional).
                                                                                                                                                                                                                                                                              • label (optional).
                                                                                                                                                                                                                                                                                Data type = string256.Type
                                                                                                                                                                                                                                                                              • summary (optional).
                                                                                                                                                                                                                                                                                Data type = string.Type

                                                                                                                                                                                                                                                                              Elements:

                                                                                                                                                                                                                                                                              tableCell.ElementGroup

                                                                                                                                                                                                                                                                              Description: Elements that can appear within a row of a table.

                                                                                                                                                                                                                                                                              Group members: <td>, <th>

                                                                                                                                                                                                                                                                              Context:

                                                                                                                                                                                                                                                                              • Occurs [1..*] within tr

                                                                                                                                                                                                                                                                              tableCellScope.Type

                                                                                                                                                                                                                                                                              One of the following symbolic values:

                                                                                                                                                                                                                                                                              • col
                                                                                                                                                                                                                                                                              • colgroup
                                                                                                                                                                                                                                                                              • row
                                                                                                                                                                                                                                                                              • rowgroup

                                                                                                                                                                                                                                                                              <tableElements>

                                                                                                                                                                                                                                                                              Description: Profile flag for the XHTML table element.

                                                                                                                                                                                                                                                                              Context:

                                                                                                                                                                                                                                                                              <targetObject>

                                                                                                                                                                                                                                                                              Description: A reference to the object, such as an assessment item, or a sub-part of the object, to which an item statistic relates.

                                                                                                                                                                                                                                                                              Context:

                                                                                                                                                                                                                                                                              Attributes:

                                                                                                                                                                                                                                                                              • identifier (required).
                                                                                                                                                                                                                                                                                Data type = string.Type
                                                                                                                                                                                                                                                                              • partIdentifier (optional).
                                                                                                                                                                                                                                                                                Data type = identifier.Type

                                                                                                                                                                                                                                                                              <tbody>

                                                                                                                                                                                                                                                                              Description: Defined by XHTML

                                                                                                                                                                                                                                                                              Context:

                                                                                                                                                                                                                                                                              • Occurs [1..*] within table

                                                                                                                                                                                                                                                                              Attributes:

                                                                                                                                                                                                                                                                              • id (optional).
                                                                                                                                                                                                                                                                                Data type = identifier.Type
                                                                                                                                                                                                                                                                              • class (optional).
                                                                                                                                                                                                                                                                                Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                              • xml:lang (optional).
                                                                                                                                                                                                                                                                              • label (optional).
                                                                                                                                                                                                                                                                                Data type = string256.Type

                                                                                                                                                                                                                                                                              Elements:

                                                                                                                                                                                                                                                                              <td>

                                                                                                                                                                                                                                                                              Description: Defined by XHTML

                                                                                                                                                                                                                                                                              Context:

                                                                                                                                                                                                                                                                                See:

                                                                                                                                                                                                                                                                                Attributes:

                                                                                                                                                                                                                                                                                • id (optional).
                                                                                                                                                                                                                                                                                  Data type = identifier.Type
                                                                                                                                                                                                                                                                                • class (optional).
                                                                                                                                                                                                                                                                                  Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                • xml:lang (optional).
                                                                                                                                                                                                                                                                                • label (optional).
                                                                                                                                                                                                                                                                                  Data type = string256.Type
                                                                                                                                                                                                                                                                                • headers (optional).
                                                                                                                                                                                                                                                                                  Data type = list of identifier.Type
                                                                                                                                                                                                                                                                                • scope (optional).
                                                                                                                                                                                                                                                                                  Data type = tableCellScope.Type
                                                                                                                                                                                                                                                                                • abbr (optional).
                                                                                                                                                                                                                                                                                  Data type = string.Type
                                                                                                                                                                                                                                                                                • axis (optional).
                                                                                                                                                                                                                                                                                  Data type = string.Type
                                                                                                                                                                                                                                                                                • rowspan (optional).
                                                                                                                                                                                                                                                                                  Data type = integer.Type
                                                                                                                                                                                                                                                                                • colspan (optional).
                                                                                                                                                                                                                                                                                  Data type = integer.Type

                                                                                                                                                                                                                                                                                Elements:

                                                                                                                                                                                                                                                                                <templateBlock>

                                                                                                                                                                                                                                                                                Description: A structural part of the item body whose visibility is conditionally controlled by a template variable.

                                                                                                                                                                                                                                                                                Context:

                                                                                                                                                                                                                                                                                  See:

                                                                                                                                                                                                                                                                                  Attributes:

                                                                                                                                                                                                                                                                                  • id (optional).
                                                                                                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                                                                                                  • class (optional).
                                                                                                                                                                                                                                                                                    Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                  • xml:lang (optional).
                                                                                                                                                                                                                                                                                  • label (optional).
                                                                                                                                                                                                                                                                                    Data type = string256.Type
                                                                                                                                                                                                                                                                                  • templateIdentifier (required).
                                                                                                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                                                                                                  • showHide (required).
                                                                                                                                                                                                                                                                                    Data type = showHide.Type
                                                                                                                                                                                                                                                                                  • identifier (required).
                                                                                                                                                                                                                                                                                    Data type = identifier.Type

                                                                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                                                                  <templateCondition>

                                                                                                                                                                                                                                                                                  Description: A template rule that contains groups of sub-rules which are followed conditionally based on the value of one or more expressions.

                                                                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                                                                    See:

                                                                                                                                                                                                                                                                                    Elements:

                                                                                                                                                                                                                                                                                    <templateDeclaration>

                                                                                                                                                                                                                                                                                    Description: Declares a template variable.

                                                                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                                                                    Attributes:

                                                                                                                                                                                                                                                                                    • identifier (required).
                                                                                                                                                                                                                                                                                      Data type = identifier.Type
                                                                                                                                                                                                                                                                                    • cardinality (required).
                                                                                                                                                                                                                                                                                      Data type = cardinality.Type
                                                                                                                                                                                                                                                                                    • baseType (optional).
                                                                                                                                                                                                                                                                                      Data type = baseType.Type
                                                                                                                                                                                                                                                                                    • paramVariable (required).
                                                                                                                                                                                                                                                                                      Data type = boolean.Type
                                                                                                                                                                                                                                                                                    • mathVariable (required).
                                                                                                                                                                                                                                                                                      Data type = boolean.Type

                                                                                                                                                                                                                                                                                    Elements:

                                                                                                                                                                                                                                                                                    templateElement.ElementGroup

                                                                                                                                                                                                                                                                                    Description: Elements whose visibility is conditionally controlled by a template variable.

                                                                                                                                                                                                                                                                                    Group members: <templateBlock>, <templateInline>

                                                                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                                                                      Not applicable.

                                                                                                                                                                                                                                                                                      <templateElse>

                                                                                                                                                                                                                                                                                      Description: A final group of rules to be followed unconditionally if all previous groups have been skipped for the containing template condition.

                                                                                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                                                                                                      <templateElseIf>

                                                                                                                                                                                                                                                                                      Description: A conditional group of rules to be considered if all previous groups have been skipped for the containing template condition.

                                                                                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                                                                                                      <templateIf>

                                                                                                                                                                                                                                                                                      Description: The first part of a template condition.

                                                                                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                                                                                                      <templateInline>

                                                                                                                                                                                                                                                                                      Description: A span of text (or equivalent) whose visibility is conditionally controlled by a template variable.

                                                                                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                                                                                        See:

                                                                                                                                                                                                                                                                                        Attributes:

                                                                                                                                                                                                                                                                                        • id (optional).
                                                                                                                                                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                                                                                                                                                        • class (optional).
                                                                                                                                                                                                                                                                                          Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                        • xml:lang (optional).
                                                                                                                                                                                                                                                                                        • label (optional).
                                                                                                                                                                                                                                                                                          Data type = string256.Type
                                                                                                                                                                                                                                                                                        • templateIdentifier (required).
                                                                                                                                                                                                                                                                                          Data type = identifier.Type
                                                                                                                                                                                                                                                                                        • showHide (required).
                                                                                                                                                                                                                                                                                          Data type = showHide.Type
                                                                                                                                                                                                                                                                                        • identifier (required).
                                                                                                                                                                                                                                                                                          Data type = identifier.Type

                                                                                                                                                                                                                                                                                        Elements:

                                                                                                                                                                                                                                                                                        <templateProcessing>

                                                                                                                                                                                                                                                                                        Description: Defines the rules used for calculating the values of the template variables.

                                                                                                                                                                                                                                                                                        Context:

                                                                                                                                                                                                                                                                                        Elements:

                                                                                                                                                                                                                                                                                        templateRule.ElementGroup

                                                                                                                                                                                                                                                                                        Description: A group of elements that define rules to be followed during template processing.

                                                                                                                                                                                                                                                                                        Group members: <exitTemplate>, <setCorrectResponse>, <setDefaultValue>, <setTemplateValue>, <templateCondition>

                                                                                                                                                                                                                                                                                        Context:

                                                                                                                                                                                                                                                                                        <templates>

                                                                                                                                                                                                                                                                                        Description: Profile flag for the item template feature.

                                                                                                                                                                                                                                                                                        Context:

                                                                                                                                                                                                                                                                                        <textElements>

                                                                                                                                                                                                                                                                                        Description: Profile flag for the XHTML text elements.

                                                                                                                                                                                                                                                                                        Context:

                                                                                                                                                                                                                                                                                        <textEntryInteraction>

                                                                                                                                                                                                                                                                                        Description: Interaction that allows the candidate to supply a span of text to fill a gap.

                                                                                                                                                                                                                                                                                        Context:

                                                                                                                                                                                                                                                                                          See:

                                                                                                                                                                                                                                                                                          Attributes:

                                                                                                                                                                                                                                                                                          • id (optional).
                                                                                                                                                                                                                                                                                            Data type = identifier.Type
                                                                                                                                                                                                                                                                                          • class (optional).
                                                                                                                                                                                                                                                                                            Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                          • xml:lang (optional).
                                                                                                                                                                                                                                                                                          • label (optional).
                                                                                                                                                                                                                                                                                            Data type = string256.Type
                                                                                                                                                                                                                                                                                          • responseIdentifier (required).
                                                                                                                                                                                                                                                                                            Data type = identifier.Type
                                                                                                                                                                                                                                                                                          • base (optional).
                                                                                                                                                                                                                                                                                            Data type = integer.Type
                                                                                                                                                                                                                                                                                          • stringIdentifier (optional).
                                                                                                                                                                                                                                                                                            Data type = identifier.Type
                                                                                                                                                                                                                                                                                          • expectedLength (optional).
                                                                                                                                                                                                                                                                                            Data type = integer.Type
                                                                                                                                                                                                                                                                                          • patternMask (optional).
                                                                                                                                                                                                                                                                                            Data type = string.Type
                                                                                                                                                                                                                                                                                          • placeholderText (optional).
                                                                                                                                                                                                                                                                                            Data type = string.Type

                                                                                                                                                                                                                                                                                          <tfoot>

                                                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                                                          • Occurs [0..1] within table

                                                                                                                                                                                                                                                                                          Attributes:

                                                                                                                                                                                                                                                                                          • id (optional).
                                                                                                                                                                                                                                                                                            Data type = identifier.Type
                                                                                                                                                                                                                                                                                          • class (optional).
                                                                                                                                                                                                                                                                                            Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                          • xml:lang (optional).
                                                                                                                                                                                                                                                                                          • label (optional).
                                                                                                                                                                                                                                                                                            Data type = string256.Type

                                                                                                                                                                                                                                                                                          Elements:

                                                                                                                                                                                                                                                                                          <th>

                                                                                                                                                                                                                                                                                          Description: Defined by XHTML

                                                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                                                          • Occurs [1..*] within tfoot

                                                                                                                                                                                                                                                                                          See:

                                                                                                                                                                                                                                                                                          Attributes:

                                                                                                                                                                                                                                                                                          • id (optional).
                                                                                                                                                                                                                                                                                            Data type = identifier.Type
                                                                                                                                                                                                                                                                                          • class (optional).
                                                                                                                                                                                                                                                                                            Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                          • xml:lang (optional).
                                                                                                                                                                                                                                                                                          • label (optional).
                                                                                                                                                                                                                                                                                            Data type = string256.Type
                                                                                                                                                                                                                                                                                          • headers (optional).
                                                                                                                                                                                                                                                                                            Data type = list of identifier.Type
                                                                                                                                                                                                                                                                                          • scope (optional).
                                                                                                                                                                                                                                                                                            Data type = tableCellScope.Type
                                                                                                                                                                                                                                                                                          • abbr (optional).
                                                                                                                                                                                                                                                                                            Data type = string.Type
                                                                                                                                                                                                                                                                                          • axis (optional).
                                                                                                                                                                                                                                                                                            Data type = string.Type
                                                                                                                                                                                                                                                                                          • rowspan (optional).
                                                                                                                                                                                                                                                                                            Data type = integer.Type
                                                                                                                                                                                                                                                                                          • colspan (optional).
                                                                                                                                                                                                                                                                                            Data type = integer.Type

                                                                                                                                                                                                                                                                                          Elements:

                                                                                                                                                                                                                                                                                          <thead>

                                                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                                                          • Occurs [0..1] within table

                                                                                                                                                                                                                                                                                          Attributes:

                                                                                                                                                                                                                                                                                          • id (optional).
                                                                                                                                                                                                                                                                                            Data type = identifier.Type
                                                                                                                                                                                                                                                                                          • class (optional).
                                                                                                                                                                                                                                                                                            Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                          • xml:lang (optional).
                                                                                                                                                                                                                                                                                          • label (optional).
                                                                                                                                                                                                                                                                                            Data type = string256.Type

                                                                                                                                                                                                                                                                                          Elements:

                                                                                                                                                                                                                                                                                          <timeDependent>

                                                                                                                                                                                                                                                                                          Description: Profile flag for the time-dependence feature.

                                                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                                                          toleranceMode.Type

                                                                                                                                                                                                                                                                                          One of the following symbolic values:

                                                                                                                                                                                                                                                                                          • absolute
                                                                                                                                                                                                                                                                                          • exact
                                                                                                                                                                                                                                                                                          • relative

                                                                                                                                                                                                                                                                                          <toolName>

                                                                                                                                                                                                                                                                                          Description: A meta-data element containing the name of the tool used to create the object.

                                                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                                                          <toolVendor>

                                                                                                                                                                                                                                                                                          Description: A meta-data element containing the name of the company that produced the tool used to create the object.

                                                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                                                          <toolVersion>

                                                                                                                                                                                                                                                                                          Description: A meta-data element containing the version of the tool used to create the object.

                                                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                                                          <tr>

                                                                                                                                                                                                                                                                                          Description: Defined by XHTML

                                                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                                                          • Occurs [1..*] within tbody
                                                                                                                                                                                                                                                                                          • Occurs [1..*] within thead

                                                                                                                                                                                                                                                                                          Attributes:

                                                                                                                                                                                                                                                                                          • id (optional).
                                                                                                                                                                                                                                                                                            Data type = identifier.Type
                                                                                                                                                                                                                                                                                          • class (optional).
                                                                                                                                                                                                                                                                                            Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                          • xml:lang (optional).
                                                                                                                                                                                                                                                                                          • label (optional).
                                                                                                                                                                                                                                                                                            Data type = string256.Type

                                                                                                                                                                                                                                                                                          Elements:

                                                                                                                                                                                                                                                                                          <truncate>

                                                                                                                                                                                                                                                                                          Description: An expression for truncating a real number to an integer.

                                                                                                                                                                                                                                                                                          Context:

                                                                                                                                                                                                                                                                                            See:

                                                                                                                                                                                                                                                                                            Elements:

                                                                                                                                                                                                                                                                                            <tt>

                                                                                                                                                                                                                                                                                            Description: Defined by XHTML

                                                                                                                                                                                                                                                                                            Context:

                                                                                                                                                                                                                                                                                              See:

                                                                                                                                                                                                                                                                                              Attributes:

                                                                                                                                                                                                                                                                                              • id (optional).
                                                                                                                                                                                                                                                                                                Data type = identifier.Type
                                                                                                                                                                                                                                                                                              • class (optional).
                                                                                                                                                                                                                                                                                                Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                              • xml:lang (optional).
                                                                                                                                                                                                                                                                                              • label (optional).
                                                                                                                                                                                                                                                                                                Data type = string256.Type

                                                                                                                                                                                                                                                                                              Elements:

                                                                                                                                                                                                                                                                                              <ul>

                                                                                                                                                                                                                                                                                              Description: Defined by XHTML

                                                                                                                                                                                                                                                                                              Context:

                                                                                                                                                                                                                                                                                                See:

                                                                                                                                                                                                                                                                                                Attributes:

                                                                                                                                                                                                                                                                                                • id (optional).
                                                                                                                                                                                                                                                                                                  Data type = identifier.Type
                                                                                                                                                                                                                                                                                                • class (optional).
                                                                                                                                                                                                                                                                                                  Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                                • xml:lang (optional).
                                                                                                                                                                                                                                                                                                • label (optional).
                                                                                                                                                                                                                                                                                                  Data type = string256.Type

                                                                                                                                                                                                                                                                                                Elements:

                                                                                                                                                                                                                                                                                                <uploadInteraction>

                                                                                                                                                                                                                                                                                                Description: Interaction in which the candidate uploads a file representing their response.

                                                                                                                                                                                                                                                                                                Context:

                                                                                                                                                                                                                                                                                                  See:

                                                                                                                                                                                                                                                                                                  Attributes:

                                                                                                                                                                                                                                                                                                  • id (optional).
                                                                                                                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                                                                                                                  • class (optional).
                                                                                                                                                                                                                                                                                                    Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                                  • xml:lang (optional).
                                                                                                                                                                                                                                                                                                  • label (optional).
                                                                                                                                                                                                                                                                                                    Data type = string256.Type
                                                                                                                                                                                                                                                                                                  • responseIdentifier (required).
                                                                                                                                                                                                                                                                                                    Data type = identifier.Type
                                                                                                                                                                                                                                                                                                  • type (optional).
                                                                                                                                                                                                                                                                                                    Data type = mimeType.Type

                                                                                                                                                                                                                                                                                                  Elements:

                                                                                                                                                                                                                                                                                                  uri.Type

                                                                                                                                                                                                                                                                                                  A trivial restriction of xsd:anyURI.

                                                                                                                                                                                                                                                                                                  <usageData>

                                                                                                                                                                                                                                                                                                  Description: The root element of a usage data XML document instance. Usage data are also referred to as item statistics.

                                                                                                                                                                                                                                                                                                  Context:

                                                                                                                                                                                                                                                                                                    Can be the root element of an XML document.

                                                                                                                                                                                                                                                                                                    Attributes:

                                                                                                                                                                                                                                                                                                    • glossary (optional). The default glossary in which the names of the itemStatistics are defined.
                                                                                                                                                                                                                                                                                                      Data type = uri.Type

                                                                                                                                                                                                                                                                                                    Elements:

                                                                                                                                                                                                                                                                                                    <usageDataVocabulary>

                                                                                                                                                                                                                                                                                                    Description: Profile flag for usage-data files.

                                                                                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                                                                                    <value>

                                                                                                                                                                                                                                                                                                    Description: A single data value from one of the base-types.

                                                                                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                                                                                    Attributes:

                                                                                                                                                                                                                                                                                                    • fieldIdentifier (optional).
                                                                                                                                                                                                                                                                                                      Data type = identifier.Type
                                                                                                                                                                                                                                                                                                    • baseType (optional).
                                                                                                                                                                                                                                                                                                      Data type = baseType.Type

                                                                                                                                                                                                                                                                                                    <var>

                                                                                                                                                                                                                                                                                                    Description: Defined by XHTML

                                                                                                                                                                                                                                                                                                    Context:

                                                                                                                                                                                                                                                                                                      See:

                                                                                                                                                                                                                                                                                                      Attributes:

                                                                                                                                                                                                                                                                                                      • id (optional).
                                                                                                                                                                                                                                                                                                        Data type = identifier.Type
                                                                                                                                                                                                                                                                                                      • class (optional).
                                                                                                                                                                                                                                                                                                        Data type = list of styleclass.Type
                                                                                                                                                                                                                                                                                                      • xml:lang (optional).
                                                                                                                                                                                                                                                                                                      • label (optional).
                                                                                                                                                                                                                                                                                                        Data type = string256.Type

                                                                                                                                                                                                                                                                                                      Elements:

                                                                                                                                                                                                                                                                                                      <variable>

                                                                                                                                                                                                                                                                                                      Description: A simple expression returning the value of an item variable

                                                                                                                                                                                                                                                                                                      Context:

                                                                                                                                                                                                                                                                                                        See:

                                                                                                                                                                                                                                                                                                        Attributes:

                                                                                                                                                                                                                                                                                                        • identifier (required).
                                                                                                                                                                                                                                                                                                          Data type = identifier.Type

                                                                                                                                                                                                                                                                                                        variableDeclaration.ElementGroup

                                                                                                                                                                                                                                                                                                        Group members: <outcomeDeclaration>, <responseDeclaration>, <templateDeclaration>

                                                                                                                                                                                                                                                                                                        Context:

                                                                                                                                                                                                                                                                                                          Not applicable.

                                                                                                                                                                                                                                                                                                          view.Type

                                                                                                                                                                                                                                                                                                          One of the following symbolic values:

                                                                                                                                                                                                                                                                                                          • author
                                                                                                                                                                                                                                                                                                          • candidate
                                                                                                                                                                                                                                                                                                          • proctor
                                                                                                                                                                                                                                                                                                          • scorer
                                                                                                                                                                                                                                                                                                          • tutor


                                                                                                                                                                                                                                                                                                          About This Document

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                          Title IMS Question and Test Interoperability XML Binding
                                                                                                                                                                                                                                                                                                          Editor Steve Lay (University of Cambridge)
                                                                                                                                                                                                                                                                                                          Version 2.0
                                                                                                                                                                                                                                                                                                          Version Date 24 January 2005
                                                                                                                                                                                                                                                                                                          Status Final Specification
                                                                                                                                                                                                                                                                                                          Summary This document describes the QTI XML Binding specification.
                                                                                                                                                                                                                                                                                                          Revision Information 24 January 2005
                                                                                                                                                                                                                                                                                                          Purpose This document has been approved by the IMS Technical Board and is made available for adoption.
                                                                                                                                                                                                                                                                                                          Document Location http://www.imsglobal.org/question/qti_v2p0/imsqti_bindv2p0.html

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                          To register any comments or questions about this specification please visit: http://www.imsglobal.org/developers/ims/imsforum/categories.cfm?catid=23

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                          List of Contributors

                                                                                                                                                                                                                                                                                                          The following individuals contributed to the development of this document:

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                          Name Organization Name Organization
                                                                                                                                                                                                                                                                                                          Niall Barr CETIS Joshua Marks McGraw-Hill
                                                                                                                                                                                                                                                                                                          Sam Easterby-Smith Canvas Learning David Poor McGraw-Hill
                                                                                                                                                                                                                                                                                                          Jeanne Ferrante ETS Greg Quirus ETS
                                                                                                                                                                                                                                                                                                          Pierre Gorissen SURF Niall Sclater CETIS
                                                                                                                                                                                                                                                                                                          Regina Hoag ETS Colin Smythe IMS
                                                                                                                                                                                                                                                                                                          Christian Kaefer McGraw-Hill GT Springer Texas Instruments
                                                                                                                                                                                                                                                                                                          John Kleeman Question Mark Colin Tattersall OUNL
                                                                                                                                                                                                                                                                                                          Steve Lay UCLES Rowin Young CETIS
                                                                                                                                                                                                                                                                                                          Jez Lord Canvas Learning    

                                                                                                                                                                                                                                                                                                          Revision History

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                          Version No. Release Date Comments
                                                                                                                                                                                                                                                                                                          Base Document 2.0 09 March 2004 The first version of the QTI Item v2.0 specification.
                                                                                                                                                                                                                                                                                                          Public Draft 2.0 07 June 2004 The Public Draft version 2.0 of the QTI Item Specification.
                                                                                                                                                                                                                                                                                                          Final 2.0 24 January 2005 The Final version 2.0 of the QTI specification.

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                           

                                                                                                                                                                                                                                                                                                          IMS Global Learning Consortium, Inc. ("IMS/GLC") is publishing the information contained in this IMS Question and Test Interoperability XML Binding ("Specification") for purposes of scientific, experimental, and scholarly collaboration only.

                                                                                                                                                                                                                                                                                                          IMS/GLC makes no warranty or representation regarding the accuracy or completeness of the Specification.
                                                                                                                                                                                                                                                                                                          This material is provided on an "As Is" and "As Available" basis.

                                                                                                                                                                                                                                                                                                          The Specification is at all times subject to change and revision without notice.

                                                                                                                                                                                                                                                                                                          It is your sole responsibility to evaluate the usefulness, accuracy, and completeness of the Specification as it relates to you.

                                                                                                                                                                                                                                                                                                          IMS/GLC would appreciate receiving your comments and suggestions.

                                                                                                                                                                                                                                                                                                          Please contact IMS/GLC through our website at http://www.imsglobal.org

                                                                                                                                                                                                                                                                                                          Please refer to Document Name:
                                                                                                                                                                                                                                                                                                          IMS Question and Test Interoperability XML Binding Revision: 24 January 2005