<?xml version="1.0" encoding="ISO-8859-1"?>
<!-- XML Schema for XML test modules  1.8b -->
<!-- (c) Vector Informatik GmbH, Stuttgart -->
<xs:schema version="1.8"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:xml="http://www.w3.org/XML/1998/namespace"
  xmlns:ai="http://www.vector-informatik.de/CANoe/TestModuleSchemaAppInfo/1.0"
  xmlns="http://www.vector-informatik.de/CANoe/TestModule/1.8"
  targetNamespace="http://www.vector-informatik.de/CANoe/TestModule/1.8"
  attributeFormDefault="unqualified">

  <!-- ========================================================================

    HOW TO DEFINE AN EXTENDED TEST MODULE XML SCHEMA
    ================================================

    Reason: If additional patterns or checks are implemented in a DLL, the XML
    definition (XML Schema) of these new patterns/checks must be added to the
    XML Schema definition of XML test modules. Use the extension method described
    here for this purpose.

    Approach: Create a new XML Schema file that imports the original schema (this
    file) and adds the definition of the new pattern/check.

    Extended schema file looks like this:

      <?xml version="1.0" encoding="ISO-8859-1"?>
      <xs:schema version="1.8"
          xmlns:xs="http://www.w3.org/2001/XMLSchema"
          xmlns:xml="http://www.w3.org/XML/1998/namespace"
          xmlns:ai="http://www.vector-informatik.de/CANoe/tmappinfo/1.0"
          xmlns="http://www.vector-informatik.de/CANoe/TestModule/1.8"
          targetNamespace="http://www.vector-informatik.de/CANoe/TestModule/1.8"
          attributeFormDefault="unqualified">
        <xs:redefine schemaLocation="testmodule.xsd">
          <xs:group name="pattern">
            <xs:choice>
              <xs:group ref="pattern"/>
              <xs:element ref="new_private_pattern"/>
            </xs:choice>
          </xs:group>
          <xs:group name="check">
            <xs:choice>
              <xs:group ref="check"/>
              <xs:element ref="new_private_check"/>
            </xs:choice>
          </xs:group>
        </xs:redefine>
        <xs:element name="new_private_pattern">
          <xs:annotation>
            <xs:documentation xml:lang="en">Pattern Description</xs:documentation>
            <xs:appinfo>
              <ai:username><ai:name lang="en">Pattern Name</ai:name></ai:username>
              <ai:classification class="pattern"/>
            </xs:appinfo>
          </xs:annotation>
          ... Definition of new pattern implemented in DLL ...
        </xs:element>
        <xs:element name="new_private_check">
          <xs:annotation>
            <xs:documentation xml:lang="en">Check Description</xs:documentation>
            <xs:appinfo>
              <ai:username><ai:name lang="en">Check Name</ai:name></ai:username>
              <ai:classification class="check"/>
            </xs:appinfo>
          </xs:annotation>
          ... Definition of new check implemented in DLL ...
        </xs:element>
      </xs:schema>

    Now use this new XML Schema (in the example called myschema.xsd) in the test
    module XML files instead of the default schema testmodule.xsd. The beginning
    of an XML test module now looks like this:

      <?xml version="1.0" encoding="UTF-8"?>
      <testmodule
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns="http://www.vector-informatik.de/CANoe/TestModule/1.8"
          xsi:schemaLocation="http://www.vector-informatik.de/CANoe/TestModule/1.8
                              myschema.xsd"
          title="Test Module Title" version="Test Module Version">
        ... test module content ...
      </testmodule>

    Because the new schema myschema.xsd references the original schema
    testmodule.xsd, both files (testmodule.xsd and myschema.xsd) must be
    available in the same directory as the test module XML file.

  ========================================================================= -->


  <xs:annotation>
    <xs:documentation xml:lang="en">Definition of XML test modules for Vector CANoe/DENoe Test Feature Set. Schema definition for CANoe 7.0.</xs:documentation>
  </xs:annotation>

  <xs:element name="testmodule">
    <xs:annotation>
      <xs:documentation xml:lang="en">Root element of every XML test module.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Test Module</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="description" minOccurs="0"/>
        <xs:element ref="variants" minOccurs="0"/>
        <xs:element ref="externalref" minOccurs="0" maxOccurs="unbounded"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="engineer"/>
          <xs:element ref="testsetup"/>
          <xs:element ref="sut"/>
          <xs:element ref="miscinfo"/>
          <xs:element ref="extendedinfo"/>
        </xs:choice>
        <xs:element ref="templates" minOccurs="0"/>
        <xs:element ref="global" minOccurs="0"/>
        <xs:element ref="preparation" minOccurs="0"/>
        <xs:element ref="constraints" minOccurs="0"/>
        <xs:element ref="conditions" minOccurs="0"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="testgroup"/>
          <xs:element ref="testcase"/>
          <xs:element ref="capltestcase"/>
          <xs:element ref="templateinstances"/>
        </xs:choice>
        <xs:element ref="completion" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="version" use="required" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="testgroup">
    <xs:annotation>
      <xs:documentation xml:lang="en">Group of test cases or nested test groups. Can be used to structure a test module (like chapters in a book) and to define group-wise constraints, conditions or preparation/completion patterns.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Test Group</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="description" minOccurs="0"/>
        <xs:element ref="externalref" minOccurs="0" maxOccurs="unbounded"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="miscinfo"/>
          <xs:element ref="extendedinfo"/>
        </xs:choice>
        <xs:element ref="preparation" minOccurs="0"/>
        <xs:element ref="constraints" minOccurs="0"/>
        <xs:element ref="conditions" minOccurs="0"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="testgroup"/>
          <xs:element ref="testcase"/>
          <xs:element ref="capltestcase"/>
          <xs:element ref="templateinstances"/>
        </xs:choice>
        <xs:element ref="completion" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="templates">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of templates, especially test case templates.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Templates</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="testcasetemplate"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="testcasetemplate">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test case defined by a sequence of test patterns.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Test Case</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="paramdef" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element ref="description" minOccurs="0"/>
        <xs:element ref="externalref" minOccurs="0" maxOccurs="unbounded"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="miscinfo"/>
          <xs:element ref="extendedinfo"/>
        </xs:choice>
        <xs:element ref="preparation" minOccurs="0"/>
        <xs:element ref="constraints" minOccurs="0"/>
        <xs:element ref="conditions" minOccurs="0"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:group ref="pattern"/>
        </xs:choice>
        <xs:element ref="completion" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="version" use="optional" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="paramdef">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a parameter in a template.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Parameter Definition</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="default" use="optional" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="templateinstances">
    <xs:annotation>
      <xs:documentation xml:lang="en">One or more instances of one template.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Template Instances</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="testcaseinstance"/>
      </xs:choice>
      <xs:attribute name="template" use="required" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="testcaseinstance">
    <xs:annotation>
      <xs:documentation xml:lang="en">Instance of a test case.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Test Case Instance</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="paramvalue"/>
      </xs:choice>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="ident" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="paramvalue">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of parameter value of a template instance.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Parameter</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:simpleContent>
        <xs:extension base="xs:string">
          <xs:attribute name="name" use="required" type="xs:string"/>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>

  <xs:element name="testcase">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test case defined by a sequence of test patterns.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Test Case</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="description" minOccurs="0"/>
        <xs:element ref="externalref" minOccurs="0" maxOccurs="unbounded"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="miscinfo"/>
          <xs:element ref="extendedinfo"/>
        </xs:choice>
        <xs:element ref="preparation" minOccurs="0"/>
        <xs:element ref="constraints" minOccurs="0"/>
        <xs:element ref="conditions" minOccurs="0"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:group ref="pattern"/>
        </xs:choice>
        <xs:element ref="completion" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="ident" use="required" type="xs:string"/>
      <xs:attribute name="version" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="capltestcase">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test case implemented in CAPL. The test case in a CAPL test case library is called. The CAPL test case is identified by its name. It is called with the given parameters. Title and identifier of this test case can be defined in XML or in the CAPL code (CAPL code overwrites definitions in XML).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">CAPL Test Case</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="externalref" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element ref="caplparam" minOccurs="0" maxOccurs="10"/>
      </xs:sequence>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="title" use="optional" type="xs:string"/>
      <xs:attribute name="ident" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="caplparam">
    <xs:annotation>
      <xs:documentation xml:lang="en">Actual parameter of a called CAPL test case. Only numerical values and strings can be passed to a CAPL test case.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Parameter</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0">
        <xs:element ref="var"/>
      </xs:choice>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="type" use="required">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="string"/>
            <xs:enumeration value="float"/>
            <xs:enumeration value="int"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
    </xs:complexType>
  </xs:element>

  <xs:element name="global">
    <xs:annotation>
      <xs:documentation xml:lang="en">The global section is used for Vector internal purposes only. Don't use this section.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Global Section</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:complexContent>
        <xs:restriction base="xs:anyType"/>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>

  <xs:element name="preparation">
    <xs:annotation>
      <xs:documentation xml:lang="en">The sequence of test patterns in the preparation section is executed before the conditions/constraints are started and before the actual pattern sequence of the test module, test group or test case. If a pattern fails, only the completion section of the test module, test group or test case is execute but not the constraints/conditions or the actual pattern sequence respective sequence of test cases or test groups. Some operations (exspecially setting variables) are only allowed within preparation.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Preparation</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="pattern"/>
        <xs:element ref="vardef"/>
        <xs:element ref="sysvardef"/>
        <xs:element ref="vardef_bytester"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="completion">
    <xs:annotation>
      <xs:documentation xml:lang="en">The pattern sequence in completion will be executed even if the test module, test group or test case is canceled (e.g. by a fail). Patterns in completion may be used to define some "tidy up" procedures that must be executed in any case.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Completion</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="pattern"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="constraints">
    <xs:annotation>
      <xs:documentation xml:lang="en">In the constraints section checks may be defined. These checks are checked during the test course in parallel to the pattern sequence. Results are written to the report and influence the test verdict, but not the test course itself. The constraints section is used for checking the test environment ("Do I have a valid check environment?").</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Constraints</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="check"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="conditions">
    <xs:annotation>
      <xs:documentation xml:lang="en">In the conditions section checks may be defined. These checks are checked during the test course in parallel to the pattern sequence. Results are written to the report and influence the test verdict, but not the test course itself. The conditions section is used for checking the SUT, i.e. these checks are part of the acutal test.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Conditions</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:group ref="check"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:group name="check">
    <xs:choice>
      <xs:element ref="cycletime_abs"/>
      <xs:element ref="cycletime_rel"/>
      <xs:element ref="distance"/>
      <xs:element ref="value_valid"/>
      <xs:element ref="goessleep"/>
      <xs:element ref="isalive"/>
      <xs:element ref="novaluechange"/>
      <xs:element ref="withintime"/>
      <xs:element ref="messages_known"/>
      <xs:element ref="error_frame_check"/>
      <xs:element ref="dlc_ok"/>
      <xs:element ref="valuedependency"/>
      <xs:element ref="occurrencetime_rel"/>
      <xs:element ref="requestresponsecheck"/>
      <xs:element ref="fallbackcheck"/>
      <xs:element ref="mostpropertyprotocolerror"/>
      <xs:element ref="mostlightlock"/>
      <xs:element ref="mostnetstate"/>
      <xs:element ref="mosterrormessage"/>
      <xs:element ref="occurrence_count"/>
      <xs:element ref="j1939_request_violation"/>
      <xs:element ref="j1939_cycletime_rel_violation"/>
      <xs:element ref="j1939_cycletime_abs_violation"/>
      <xs:element ref="j1939_BAM_violation"/>
      <xs:element ref="j1939_RTS_CTS_violation"/>
      <xs:element ref="j1939_ACL_violation"/>
      <xs:element ref="j1939_messages_known"/>
      <xs:element ref="j1939_rules_specific"/>
    </xs:choice>
  </xs:group>

  <xs:group name="pattern">
    <xs:choice>
      <xs:element ref="comment"/>
      <xs:element ref="valuecomment"/>
      <xs:element ref="wait"/>
      <xs:element ref="initialize"/>
      <xs:element ref="statecheck"/>
      <xs:element ref="statechange"/>
      <xs:element ref="requestresponse"/>
      <xs:element ref="replay"/>
      <xs:element ref="stimulate_ramp"/>
      <xs:element ref="diagservicecheck"/>
      <xs:element ref="untilend"/>
      <xs:element ref="testerconfirmation"/>
      <xs:element ref="syscall"/>
      <xs:element ref="canstress_configure"/>
      <xs:element ref="canstress_state"/>
      <xs:element ref="fblocksexistence"/>
      <xs:element ref="netblockcomplete"/>
      <xs:element ref="functionsinfblock"/>
      <xs:element ref="genericfblocktest"/>
      <xs:element ref="isproperty"/>
      <xs:element ref="j1939_request_response"/>
      <xs:element ref="j1939_command_response"/>
      <xs:element ref="j1939_request_ACL"/>
      <xs:element ref="j1939_conflict_ACL"/>
      <xs:element ref="j1939_commanded_address"/>
    </xs:choice>
  </xs:group>

  <xs:element name="vardef">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a variable (set once, read multiple) that can be used within the XML test module. The variable has no meaning within other parts of CANoe. A constant value is given or the value is read from
        a signal.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Variable Definition</ai:name></ai:username>
        <ai:usagerestriction class="read"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="cansignal"/>
        <xs:element ref="linsignal"/>
        <xs:element ref="flexraysignal"/>
        <xs:element ref="envvar"/>
        <xs:element ref="sysvar"/>
        <xs:element ref="value"/>
      </xs:choice>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="type" use="required">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="string"/>
            <xs:enumeration value="float"/>
            <xs:enumeration value="int"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="default" use="optional" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="vardef_bytester">
    <xs:annotation>
      <xs:documentation xml:lang="en"> Definition of a variable (set once, read multiple) that can be used within the XML test module. The variable has no meaning within other parts of CANoe. The variable value is requested from the user using a
        dialog box.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Variable Definition by Tester</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:simpleContent>
        <xs:extension base="xs:string">
          <xs:attribute name="name" use="required" type="xs:string"/>
          <xs:attribute name="type" use="required">
            <xs:simpleType>
              <xs:restriction base="xs:NMTOKEN">
                <xs:enumeration value="string"/>
                <xs:enumeration value="float"/>
                <xs:enumeration value="int"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
          <xs:attribute name="timeout" use="optional" type="xs:string"/>
          <xs:attribute name="default" use="optional" type="xs:string"/>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>

  <xs:element name="sysvardef">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a CANoe system variable (set once, read multiple). A system variable defined by the XML test module can be used in CANoe (read only).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">System Variable Definition</ai:name></ai:username>
        <ai:usagerestriction class="read"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="cansignal"/>
        <xs:element ref="linsignal"/>
        <xs:element ref="flexraysignal"/>
        <xs:element ref="envvar"/>
      </xs:choice>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="type" use="required">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="string"/>
            <xs:enumeration value="float"/>
            <xs:enumeration value="int"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="default" use="required" type="xs:string"/>
      <xs:attribute name="namespace" use="optional" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="var">
    <xs:annotation>
      <xs:documentation xml:lang="en">This element is used to use a variable that is defined within the XML test module (something like reading a variable). The var element is used instead of literal data.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Variable</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="name" use="required" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="eq">
    <xs:annotation>
      <xs:documentation xml:lang="en">Comparison operator "equal" or operator "becomes"; this is the default operator if no operator is given.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">=</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="var"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="ne">
    <xs:annotation>
      <xs:documentation xml:lang="en">Comparison operator "not equal".</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">!=</ai:name></ai:username>
        <ai:restriction class="set" element="forbidden"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="var"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="lt">
    <xs:annotation>
      <xs:documentation xml:lang="en">Comparison operator "lesser than".</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">&lt;</ai:name></ai:username>
        <ai:restriction class="set" element="forbidden"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="var"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="gt">
    <xs:annotation>
      <xs:documentation xml:lang="en">Comparison operator "greater than".</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">&gt;</ai:name></ai:username>
        <ai:restriction class="set" element="forbidden"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="var"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="le">
    <xs:annotation>
      <xs:documentation xml:lang="en">Comparison operator "lesser or equal".</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">&lt;=</ai:name></ai:username>
        <ai:restriction class="set" element="forbidden"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="var"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="ge">
    <xs:annotation>
      <xs:documentation xml:lang="en">Comparison operator "greater or equal".</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">&gt;=</ai:name></ai:username>
        <ai:restriction class="set" element="forbidden"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="var"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="range">
    <xs:annotation>
      <xs:documentation xml:lang="en">Comparison operator "range". A given range includes the values defined by "from" and "to".</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Range</ai:name></ai:username>
        <ai:restriction class="set" element="forbidden"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="from"/>
        <xs:element ref="to"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="from">
    <xs:annotation>
      <xs:documentation xml:lang="en">Lower limit of a range. Value is included in the range.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">From</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="var"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="to">
    <xs:annotation>
      <xs:documentation xml:lang="en">Upper limit of a range. Value is included in the range.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">To</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="var"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="one_of">
    <xs:annotation>
      <xs:documentation xml:lang="en">Comparison operator "one_of". True, if one of the included conditions match.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">One Of</ai:name></ai:username>
        <ai:restriction class="set" element="forbidden"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="eq"/>
        <xs:element ref="range"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:group name="opvalue">
    <xs:choice>
      <xs:element ref="eq"/>
      <xs:element ref="ne"/>
      <xs:element ref="lt"/>
      <xs:element ref="gt"/>
      <xs:element ref="le"/>
      <xs:element ref="ge"/>
      <xs:element ref="range"/>
      <xs:element ref="one_of"/>
      <xs:element ref="var"/>
    </xs:choice>
  </xs:group>

  <xs:element name="cansignal">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a signal from the CAN bus (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">CAN Signal</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
        <ai:restriction class="read" content="none"/>
        <ai:restriction class="set" content="subortext"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:group ref="opvalue" minOccurs="0" maxOccurs="1"/>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="msg" use="optional" type="xs:string"/>
      <xs:attribute name="node" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="linsignal">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a signal from the LIN bus (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">LIN Signal</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="LIN"/>
        </ai:availability>
        <ai:restriction class="read" content="none"/>
        <ai:restriction class="set" content="subortext"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:group ref="opvalue" minOccurs="0" maxOccurs="1"/>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="msg" use="optional" type="xs:string"/>
      <xs:attribute name="node" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="flexraysignal">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a signal from the LIN bus (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">FlexRay Signal</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="FlexRay"/>
        </ai:availability>
        <ai:restriction class="read" content="none"/>
        <ai:restriction class="set" content="subortext"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:group ref="opvalue" minOccurs="0" maxOccurs="1"/>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="frame" use="optional" type="xs:string"/>
      <xs:attribute name="node" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="envvar">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of an environment variable value (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Environment Variable</ai:name></ai:username>
        <ai:restriction class="read" content="none"/>
        <ai:restriction class="set" content="subortext"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:group ref="opvalue" minOccurs="0" maxOccurs="1"/>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="sysvar">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of an system variable value (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">System Variable</ai:name></ai:username>
        <ai:restriction class="read" content="none"/>
        <ai:restriction class="set" content="subortext"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:group ref="opvalue" minOccurs="0" maxOccurs="1"/>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="namespace" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="canmsg">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of an CAN message (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">CAN Message</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
        <ai:restriction class="ident" content="none"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="byte"/>
          <xs:element ref="byteref"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="signal"/>
          <xs:element ref="signalref"/>
        </xs:choice>
      </xs:choice>
      <xs:attribute name="id" use="required" type="xs:string"/>
      <xs:attribute name="node" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="channel" use="optional" type="xs:string"/>
      <xs:attribute name="dlc" use="optional" type="xs:string"/>
      <xs:attribute name="dir" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="rx"/>
            <xs:enumeration value="tx"/>
            <xs:enumeration value="txrequest"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="rtr" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="nortr"/>
            <xs:enumeration value="rtr"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="type" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="std"/>
            <xs:enumeration value="ext"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="msgflags" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="nerr"/>
            <xs:enumeration value="highvoltage"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="linframe">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of an LIN frame (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">LIN Frame</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="LIN"/>
        </ai:availability>
        <ai:restriction class="ident" content="none"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="byte"/>
          <xs:element ref="byteref"/>
        </xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="signal"/>
          <xs:element ref="signalref"/>
        </xs:choice>
      </xs:choice>
      <xs:attribute name="id" use="required" type="xs:string"/>
      <xs:attribute name="node" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="channel" use="optional" type="xs:string"/>
      <xs:attribute name="dir" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="rx"/>
            <xs:enumeration value="tx"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="mostmsg">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of an MOST message (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST Message</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
        <ai:restriction class="ident" content="none"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="byte"/>
          <xs:element ref="byteref"/>
        </xs:choice>
        <xs:element ref="param" minOccurs="0" maxOccurs="unbounded"/>
      </xs:choice>
      <xs:attribute name="fblock" use="optional" type="xs:string"/>
      <xs:attribute name="function" use="optional" type="xs:string"/>
      <xs:attribute name="optype" use="optional" type="xs:string"/>
      <xs:attribute name="name" use="optional" type="xs:string"/>
      <xs:attribute name="instance" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="channel" use="optional" type="xs:string"/>
      <xs:attribute name="tellen" use="optional" type="xs:string"/>
      <xs:attribute name="telid" use="optional" type="xs:string"/>
      <xs:attribute name="dir" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="rx"/>
            <xs:enumeration value="tx"/>
            <xs:enumeration value="txrequest"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="sa" use="optional" type="xs:string"/>
      <xs:attribute name="da" use="optional" type="xs:string"/>
      <xs:attribute name="ams" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="ams"/>
            <xs:enumeration value="ctrl"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="spy" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="node"/>
            <xs:enumeration value="spy"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="mostsysmsg">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of an MOST system message (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST System Message</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
        <ai:restriction class="ident" content="none"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="byte" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="rtype" use="required" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="channel" use="optional" type="xs:string"/>
      <xs:attribute name="dir" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="rx"/>
            <xs:enumeration value="tx"/>
            <xs:enumeration value="txrequest"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="sa" use="optional" type="xs:string"/>
      <xs:attribute name="da" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_pg">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of an J1939 PG (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 PG</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
        <ai:restriction class="ident" content="none"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="byte"/>
          <xs:element ref="byteref"/>
        </xs:choice>
        <xs:element ref="signal" minOccurs="0" maxOccurs="unbounded"/>
      </xs:choice>
      <xs:attribute name="id" use="required" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="channel" use="optional" type="xs:string"/>
      <xs:attribute name="dlc" use="optional" type="xs:string"/>
      <xs:attribute name="dir" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="rx"/>
            <xs:enumeration value="tx"/>
            <xs:enumeration value="txrequest"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="priority" use="optional" type="xs:string"/>
      <xs:attribute name="sendNode" use="optional" type="xs:string"/>
      <xs:attribute name="receiveNode" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="signal">
    <xs:annotation>
      <xs:documentation xml:lang="en">Signal of a message (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Signal</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:group ref="opvalue" minOccurs="0" maxOccurs="1"/>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="byte">
    <xs:annotation>
      <xs:documentation xml:lang="en">Data byte of a message (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Byte</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:group ref="opvalue" minOccurs="0" maxOccurs="1"/>
      <xs:attribute name="pos" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="signalref">
    <xs:annotation>
      <xs:documentation xml:lang="en">Signal of a message. The signal value is checked against the value the referenced signal of another message. This element can be used only within the check "requestresponsecheck".</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Signal Reference</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="refname" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="byteref">
    <xs:annotation>
      <xs:documentation xml:lang="en">Data byte of a message. The byte value is checked against the value the referenced data byte of another message. This element can be used only within the check "requestresponsecheck".</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Byte Reference</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="pos" use="required" type="xs:string"/>
      <xs:attribute name="refpos" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="param">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of a MOST message (set or check, depends on context).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Parameter</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:group ref="opvalue" minOccurs="0" maxOccurs="1"/>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="node">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a network node.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Node</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="name" use="required" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_node">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a node in a J1939 network.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Node</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="name" use="optional" type="xs:string"/>
      <xs:attribute name="address" use="optional" type="xs:string"/>
      <xs:attribute name="aac" use="optional" type="xs:string"/>
      <xs:attribute name="ig" use="optional" type="xs:string"/>
      <xs:attribute name="sys" use="optional" type="xs:string"/>
      <xs:attribute name="sysi" use="optional" type="xs:string"/>
      <xs:attribute name="fct" use="optional" type="xs:string"/>
      <xs:attribute name="fcti" use="optional" type="xs:string"/>
      <xs:attribute name="ecui" use="optional" type="xs:string"/>
      <xs:attribute name="mc" use="optional" type="xs:string"/>
      <xs:attribute name="in" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="inlist">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of list of MOST function blocks or functions. This list is used to define function blocks or functions that should be explicitely considered.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Include List</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="fblock" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element ref="function" minOccurs="0" maxOccurs="unbounded"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="outlist">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of list of MOST function blocks. This list is used to define function blocks that should be not considered.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Exclude List</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="fblock" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="exceptionlist">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of an exception list of MOST function blocks or MOST functions.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Exception List</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="fblock" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element ref="function" minOccurs="0" maxOccurs="unbounded"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="fblock">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a MOST functin block (FBlock).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">FBlock</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="id" use="required" type="xs:string"/>
      <xs:attribute name="instance" use="optional" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="function">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a MOST function.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Function</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="id" use="required" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="sender">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a J1939 sender node.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Sender</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="j1939_node" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="receiver">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a J1939 receiver node.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Receiver</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="j1939_node" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="command">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of a J1939 command PG.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Command PG</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="j1939_pg" minOccurs="0" maxOccurs="1"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="engineer">
    <xs:annotation>
      <xs:documentation xml:lang="en">Information (list of name/value pairs) about the test engineer.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Engineer</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="info" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="testsetup">
    <xs:annotation>
      <xs:documentation xml:lang="en">Information (list of name/value pairs) about the test setup.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Test Setup</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="info" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="sut">
    <xs:annotation>
      <xs:documentation xml:lang="en">Information (list of name/value pairs) about the system under test (SUT).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">System Under Test</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="info" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="miscinfo">
    <xs:annotation>
      <xs:documentation xml:lang="en">Additional, miscellaneous block of information (list of name/value pairs).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Miscellaneous Information</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="info" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="extendedinfo">
    <xs:annotation>
      <xs:documentation xml:lang="en">Additional information in an arbitrary format (e.g. HTML).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Extended Information</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:complexContent>
        <xs:extension base="xs:anyType">
          <xs:attribute name="type" use="required">
            <xs:simpleType>
              <xs:restriction base="xs:NMTOKEN">
                <xs:enumeration value="html"/>
                <xs:enumeration value="text"/>
                <xs:enumeration value="other"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
          <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>

  <xs:element name="comment">
    <xs:annotation>
      <xs:documentation xml:lang="en">Comments within a test course. Will be copied into the report.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Comment</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:simpleContent>
        <xs:extension base="xs:string">
          <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>

  <xs:element name="valuecomment">
    <xs:annotation>
      <xs:documentation xml:lang="en">Report a current value, e.g. an actual CAN signal or value of an environment variable. A description can be given to describe what value is reported and why it is reported.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Value Comment</ai:name></ai:username>
        <ai:usagerestriction class="read"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="description"/>
        <xs:choice>
          <xs:element ref="cansignal"/>
          <xs:element ref="linsignal"/>
          <xs:element ref="flexraysignal"/>
          <xs:element ref="envvar"/>
          <xs:element ref="sysvar"/>
        </xs:choice>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="info">
    <xs:annotation>
      <xs:documentation xml:lang="en">Information as a name/description pair.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Information</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="name"/>
        <xs:element ref="description"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="name" type="xs:string">
    <xs:annotation>
      <xs:documentation xml:lang="en">A name.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Name</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
  </xs:element>

  <xs:element name="description" type="xs:string">
    <xs:annotation>
      <xs:documentation xml:lang="en">Description text.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Description</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
  </xs:element>

  <xs:element name="variants">
    <xs:annotation>
      <xs:documentation xml:lang="en">List of variants used in the XML test module.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Variants</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="variant" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="variant">
    <xs:annotation>
      <xs:documentation xml:lang="en">Defines a variant in the XML test module. The variant is defined by its short name (to identify the variant within the XML text, the attribute "name") and a long name that is used at the user interface (this is the content of the element "variant").</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Variant</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:simpleContent>
        <xs:extension base="xs:string">
          <xs:attribute name="name" use="required" type="xs:NMTOKEN"/>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>

  <xs:element name="value">
    <xs:annotation>
      <xs:documentation xml:lang="en">Variant depending value of a variable definition.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Value</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:simpleContent>
        <xs:extension base="xs:string">
          <xs:attribute name="variants" use="required" type="xs:NMTOKENS"/>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>

  <xs:element name="externalref">
    <xs:annotation>
      <xs:documentation xml:lang="en">Reference to an external entity (e.g. to a DOORS requirement).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">External Reference</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:simpleContent>
        <xs:extension base="xs:string">
          <xs:attribute name="title" use="optional" type="xs:string"/>
          <xs:attribute name="type" use="required">
            <xs:simpleType>
              <xs:restriction base="xs:NMTOKEN">
                <xs:enumeration value="url"/>
                <xs:enumeration value="doors"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>

  <!-- Checks -->

  <xs:element name="cycletime_abs">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Absolute cycle time supervision.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Absolut Cycle Time</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
        <ai:usagerestriction class="ident"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="canmsg"/>
      </xs:sequence>
      <xs:attribute name="min" use="optional" type="xs:string"/>
      <xs:attribute name="max" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="cycletime_rel">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Relative cycle time supervision.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Relative Cycle Time</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
        <ai:usagerestriction class="ident"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="canmsg"/>
        <xs:element ref="node"/>
      </xs:choice>
      <xs:attribute name="min" use="optional" type="xs:string"/>
      <xs:attribute name="max" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="distance">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Message distance supervision.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Message Distance</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
          <ai:bussystem name="LIN"/>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="reference"/>
        <xs:element ref="observed"/>
      </xs:sequence>
      <xs:attribute name="min" use="optional" type="xs:string"/>
      <xs:attribute name="max" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
  </xs:complexType>
  </xs:element>

  <xs:element name="reference">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of reference message within check "message distance supervision".</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Reference Message</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
          <ai:bussystem name="LIN"/>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="canmsg"/>
        <xs:element ref="mostmsg"/>
        <xs:element ref="linframe"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="observed">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of observed message within check "message distance supervision".</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Observed Message</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
          <ai:bussystem name="LIN"/>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="canmsg"/>
        <xs:element ref="mostmsg"/>
        <xs:element ref="linframe"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="value_valid">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Signal value supervision.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Signal Value</ai:name></ai:username>
        <ai:classification class="check"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="cansignal"/>
        <xs:element ref="linsignal"/>
        <xs:element ref="flexraysignal"/>
        <xs:element ref="envvar"/>
        <xs:element ref="sysvar"/>
      </xs:choice>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="goessleep">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Node babbling.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Node Inactive</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
        <ai:usagerestriction class="ident"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="node"/>
        <xs:element ref="canmsg" minOccurs="0" maxOccurs="unbounded"/>
      </xs:choice>
      <xs:attribute name="time" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="isalive">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Node dead.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Node Active</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
          <ai:bussystem name="LIN"/>
        </ai:availability>
        <ai:usagerestriction class="ident"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="node"/>
        <xs:element ref="canmsg" minOccurs="0" maxOccurs="unbounded"/>
      </xs:choice>
      <xs:attribute name="time" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="novaluechange">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Signal value change.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Signal Value Constancy</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:usagerestriction class="read"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="cansignal"/>
        <xs:element ref="linsignal"/>
        <xs:element ref="flexraysignal"/>
        <xs:element ref="envvar"/>
        <xs:element ref="sysvar"/>
      </xs:choice>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="withintime">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Timeout.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Timeout</ai:name></ai:username>
        <ai:classification class="check"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="max" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="messages_known">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Undefined message received.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Unknown Message Received</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="error_frame_check">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: </xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Error Frame</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="max" use="required" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="dlc_ok">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: DLC supervision.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">DLC Monitoring</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
        <ai:usagerestriction class="ident"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="canmsg"/>
        <xs:element ref="node"/>
      </xs:choice>
      <xs:attribute use="optional" name="dir">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="rx"/>
            <xs:enumeration value="tx"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="valuedependency">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Value invariant supervision.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Values Invariant</ai:name></ai:username>
        <ai:classification class="check"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="while"/>
        <xs:element ref="match"/>
      </xs:sequence>
      <xs:attribute name="mintime" use="optional" type="xs:string"/>
      <xs:attribute name="timeout" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="while">
    <xs:annotation>
      <xs:documentation xml:lang="en">Precondition in value invariant supervision check. While this condition is true the matching value has to be true.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Value Precondition</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="cansignal"/>
        <xs:element ref="linsignal"/>
        <xs:element ref="flexraysignal"/>
        <xs:element ref="envvar"/>
        <xs:element ref="sysvar"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="match">
    <xs:annotation>
      <xs:documentation xml:lang="en">Matching value of value invariant supervision check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Matching Value</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="cansignal"/>
        <xs:element ref="linsignal"/>
        <xs:element ref="flexraysignal"/>
        <xs:element ref="envvar"/>
        <xs:element ref="sysvar"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="occurrencetime_rel">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Relative message occurrence supervision.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Occurrence of a Message</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="canmsg"/>
        <xs:element ref="node"/>
      </xs:choice>
      <xs:attribute name="min" use="optional" type="xs:string"/>
      <xs:attribute name="max" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="requestresponsecheck">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Message routing observing check (e.g. for Gateway-tests).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Request Response Check</ai:name></ai:username>
        <ai:classification class="check"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="request">
          <xs:annotation>
            <xs:appinfo>
              <ai:usagerestriction class="ident"/>
            </xs:appinfo>
          </xs:annotation>
        </xs:element>
        <xs:element ref="response"/>
      </xs:sequence>
      <xs:attribute name="mintime" use="optional" type="xs:string"/>
      <xs:attribute name="timeout" use="required" type="xs:string"/>
      <xs:attribute name="observetime" use="optional" type="xs:string"/>
      <xs:attribute name="one2one" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="yes"/>
            <xs:enumeration value="no"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="fallbackcheck">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Fallback reaction check (e.g. for Gateway-tests).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Fallback Observation</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
          <ai:bussystem name="MOST"/>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="ondropout"/>
        <xs:element ref="fallback"/>
      </xs:sequence>
      <xs:attribute name="timeout" use="required" type="xs:string"/>
      <xs:attribute name="observetime" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="ondropout">
    <xs:annotation>
      <xs:documentation xml:lang="en">Element is part of the fallback check. If the event defined here is missing for a defined time, the fallback action is checked.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Drop Out</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
          <ai:bussystem name="MOST"/>
          <ai:bussystem name="J1939"/>
        </ai:availability>
        <ai:usagerestriction class="ident"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="canmsg"/>
        <xs:element ref="mostmsg"/>
        <xs:element ref="j1939_pg"/>
      </xs:choice>
      <xs:attribute name="time" use="required" type="xs:string"/>
      <xs:attribute name="missing" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="all"/>
            <xs:enumeration value="any"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="fallback">
    <xs:annotation>
      <xs:documentation xml:lang="en">Element is part of the fallback check. The fallback action is defined with this element.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Fallback</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
          <ai:bussystem name="MOST"/>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="canmsg"/>
        <xs:element ref="mostmsg"/>
        <xs:element ref="envvar"/>
        <xs:element ref="sysvar"/>
        <xs:element ref="j1939_pg"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="occurrence_count">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check: Absence of defined messages.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Absence of Defined Messages</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="canmsg"/>
        <xs:element ref="j1939_pg"/>
      </xs:choice>
      <xs:attribute name="maxcount" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="mostpropertyprotocolerror">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (MOST specific): Property protocol error check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST Protocol Observation</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="property" use="required" type="xs:string"/>
      <xs:attribute name="instance" use="optional" type="xs:string"/>
      <xs:attribute name="answertimeout" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="mostlightlock">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (MOST specific): Light and lock state check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST Light&amp;Lock Observation</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="eventtype" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="criticalunlock"/>
            <xs:enumeration value="stablelock"/>
            <xs:enumeration value="shortunlock"/>
            <xs:enumeration value="lightoff"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="mostnetstate">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (MOST specific): NetState check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST NetState Observation</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="oldstate" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="confignotok"/>
            <xs:enumeration value="poweroff"/>
            <xs:enumeration value="netinterfaceinit"/>
            <xs:enumeration value="undefined"/>
            <xs:enumeration value="configok"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="newstate" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="confignotok"/>
            <xs:enumeration value="poweroff"/>
            <xs:enumeration value="netinterfaceinit"/>
            <xs:enumeration value="undefined"/>
            <xs:enumeration value="configok"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="mosterrormessage">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (MOST specific): Error message (occurrance) check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST Error Messages</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="sa" use="required" type="xs:string"/>
      <xs:attribute name="name" use="optional" type="xs:string"/>
      <xs:attribute name="instance" use="optional" type="xs:string"/>
      <xs:attribute name="code" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_ACL_violation">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (J1939 specific): Address claiming violation check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Address Claiming</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="1" maxOccurs="unbounded">
        <xs:element ref="j1939_node"/>
      </xs:choice>
      <xs:attribute name="timeout" use="optional" type="xs:string"/>
      <xs:attribute name="allowAddressUsageBeforeACL" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="0"/>
            <xs:enumeration value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="allowNonExpectedACL" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="0"/>
            <xs:enumeration value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="allowClaimingOfOtherAddress" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="0"/>
            <xs:enumeration value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_request_violation">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (J1939 specific): Request violation check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Request</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="j1939_node" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="j1939_pg" minOccurs="0" maxOccurs="1"/>
      </xs:choice>
      <xs:attribute name="timeout" use="optional" type="xs:string"/>
      <xs:attribute name="requestInhibitTime" use="optional" type="xs:string"/>
      <xs:attribute name="expect" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="response"/>
            <xs:enumeration value="NACK"/>
            <xs:enumeration value="PACK"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="allowRequestIfPending" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="0"/>
            <xs:enumeration value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="context" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="inhibitTime"/>
            <xs:enumeration value="retries"/>
            <xs:enumeration value="evaluateACK"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_BAM_violation">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (J1939 specific): Broadcast Announce Message (BAM) violation check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 BAM</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="j1939_node"/>
      </xs:choice>
      <xs:attribute name="min" use="optional" type="xs:string"/>
      <xs:attribute name="max" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_cycletime_rel_violation">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (J1939 specific): Relative cycle time violation check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Relative Cycle Time</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="j1939_pg"/>
      </xs:choice>
      <xs:attribute name="min" use="required" type="xs:string"/>
      <xs:attribute name="max" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_cycletime_abs_violation">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (J1939 specific): Absolute cycle time violation check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Absolute Cycle Time</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="1">
        <xs:element ref="j1939_pg"/>
      </xs:choice>
      <xs:attribute name="min" use="required" type="xs:string"/>
      <xs:attribute name="max" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_RTS_CTS_violation">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (J1939 specific): Transport Protocol (RTS / CTS) violation  check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 RTS/CTS</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="sender"/>
        <xs:element ref="receiver"/>
      </xs:choice>
      <xs:attribute name="t1" use="optional" type="xs:string"/>
      <xs:attribute name="t2" use="optional" type="xs:string"/>
      <xs:attribute name="t3" use="optional" type="xs:string"/>
      <xs:attribute name="t4" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_messages_known">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (J1939 specific): Undefined J1939 PG received check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Messages Known</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="sender" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="receiver" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="j1939_pg" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="context" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="pgn"/>
            <xs:enumeration value="dp"/>
            <xs:enumeration value="edp"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_rules_specific">
    <xs:annotation>
      <xs:documentation xml:lang="en">Check (J1939 specific): Domain rules check.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Rules Specific</ai:name></ai:username>
        <ai:classification class="check"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="sender" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="receiver" minOccurs="0" maxOccurs="1"/>
      </xs:sequence>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="context" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="byteOrder"/>
            <xs:enumeration value="TPDataMinDLC"/>
            <xs:enumeration value="dlc"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <!-- Patterns -->

  <xs:element name="wait">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Wait for specified time.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Wait</ai:name></ai:username>
        <ai:classification class="pattern"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="time" use="required" type="xs:string"/>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="initialize">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Initialization of a vector, then wait.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Initialize</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:usagerestriction class="set"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="cansignal"/>
          <xs:element ref="linsignal"/>
          <xs:element ref="flexraysignal"/>
          <xs:element ref="envvar"/>
          <xs:element ref="sysvar"/>
          <xs:element ref="canmsg"/>
          <xs:element ref="mostmsg"/>
          <xs:element ref="mostsysmsg"/>
          <xs:element ref="j1939_pg"/>
        </xs:choice>
      </xs:sequence>
      <xs:attribute name="wait" use="optional" type="xs:string"/>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="statechange">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Set input vector, wait, then check target vector.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">State Change</ai:name></ai:username>
        <ai:classification class="pattern"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="in"/>
        <xs:element ref="expected"/>
      </xs:sequence>
      <xs:attribute name="wait" use="required" type="xs:string"/>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="in">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Input vector of statechange pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Stimulation</ai:name></ai:username>
        <ai:usagerestriction class="set"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="cansignal"/>
        <xs:element ref="linsignal"/>
        <xs:element ref="flexraysignal"/>
        <xs:element ref="envvar"/>
        <xs:element ref="sysvar"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="expected">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Target vector of statechange pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Expected</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="cansignal"/>
        <xs:element ref="linsignal"/>
        <xs:element ref="flexraysignal"/>
        <xs:element ref="envvar"/>
        <xs:element ref="sysvar"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="statecheck">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Wait, then check target vector.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">State Check</ai:name></ai:username>
        <ai:classification class="pattern"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="expected"/>
      </xs:sequence>
      <xs:attribute name="wait" use="required" type="xs:string"/>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="requestresponse">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Send message, then wait for response.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Request Response</ai:name></ai:username>
        <ai:classification class="pattern"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="request"/>
        <xs:element ref="response"/>
      </xs:sequence>
      <xs:attribute name="mintime" use="optional" type="xs:string"/>
      <xs:attribute name="timeout" use="required" type="xs:string"/>
      <xs:attribute name="observetime" use="optional" type="xs:string"/>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="request">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of request in requestresponse check or pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Request</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="canmsg"/>
        <xs:element ref="envvar"/>
        <xs:element ref="sysvar"/>
        <xs:element ref="linframe"/>
        <xs:element ref="mostmsg"/>
        <xs:element ref="mostsysmsg"/>
        <xs:element ref="j1939_pg"/>
      </xs:choice>
      <xs:attribute name="sendinterval" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="response">
    <xs:annotation>
      <xs:documentation xml:lang="en">Definition of response in requestresponse check or pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Response</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element ref="canmsg"/>
        <xs:element ref="envvar"/>
        <xs:element ref="sysvar"/>
        <xs:element ref="linframe"/>
        <xs:element ref="mostmsg"/>
        <xs:element ref="mostsysmsg"/>
        <xs:element ref="j1939_pg"/>
      </xs:choice>
      <xs:attribute name="joincondition" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="and"/>
            <xs:enumeration value="or"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="replay">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Replay a log/macro file.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Replay</ai:name></ai:username>
        <ai:classification class="pattern"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="file" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="stimulate_ramp">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Stimulate signal with a ramp signal.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Stimulate Ramp</ai:name></ai:username>
        <ai:classification class="pattern"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="cansignal"/>
        <xs:element ref="envvar"/>
      </xs:choice>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="cycle" use="required" type="xs:string"/>
      <xs:attribute name="duration" use="required" type="xs:string"/>
      <xs:attribute name="timeUp" use="required" type="xs:string"/>
      <xs:attribute name="timeDown" use="required" type="xs:string"/>
      <xs:attribute name="timeHigh" use="required" type="xs:string"/>
      <xs:attribute name="timeLow" use="required" type="xs:string"/>
      <xs:attribute name="min" use="optional" type="xs:string"/>
      <xs:attribute name="max" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="diagservicecheck">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Call a diagnostics service and check response.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Diagnostics Service Check</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="diagvalue" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="ecu" use="required" type="xs:string"/>
      <xs:attribute name="class" use="required" type="xs:string"/>
      <xs:attribute name="instance" use="required" type="xs:string"/>
      <xs:attribute name="service" use="required" type="xs:string"/>
      <xs:attribute name="timeout"  use="optional" type="xs:string"/>
      <xs:attribute name="result" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="any"/>
            <xs:enumeration value="positive"/>
            <xs:enumeration value="negative"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="diagvalue">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Parameter of a diagnostics request or response.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Value</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:group ref="opvalue" minOccurs="0" maxOccurs="1"/>
      <xs:attribute name="qualifier" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="untilend">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Wait until test case is stopped by user.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Until End</ai:name></ai:username>
        <ai:classification class="pattern"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="wait" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="testerconfirmation">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Pops up a dialog for tester confirmation with yes or no.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Tester Confirmation</ai:name></ai:username>
        <ai:classification class="pattern"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:simpleContent>
        <xs:extension base="xs:string">
          <xs:attribute name="title" use="required" type="xs:string"/>
          <xs:attribute name="wait"  use="optional" type="xs:string"/>
          <xs:attribute name="passedbutton" use="optional">
            <xs:simpleType>
              <xs:restriction base="xs:NMTOKEN">
                <xs:enumeration value="yes"/>
                <xs:enumeration value="no"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
          <xs:attribute name="timeoutresult" use="optional">
            <xs:simpleType>
              <xs:restriction base="xs:NMTOKEN">
                <xs:enumeration value="failed"/>
                <xs:enumeration value="passed"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
          <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>

  <xs:element name="syscall">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Execute external program.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">System Call</ai:name></ai:username>
        <ai:classification class="pattern"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="invoke"/>
        <xs:element ref="expectedexitcode" minOccurs="0" maxOccurs="1"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="timeout" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="invoke" type="xs:string">
    <xs:annotation>
      <xs:documentation xml:lang="en">Name of program to be executed by system call pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Program Name</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
  </xs:element>

  <xs:element name="expectedexitcode">
    <xs:annotation>
      <xs:documentation xml:lang="en">Expected exit code of executed program (system call pattern).</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Expected Exit Code</ai:name></ai:username>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:group ref="opvalue" minOccurs="0" maxOccurs="1"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="canstress_configure">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: configure an attached CANstress device.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">CANstress Configuration</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="baseconfig"/>
        <xs:element ref="analogconfig" minOccurs="0"/>
        <xs:element ref="digitalconfig" minOccurs="0"/>
        <xs:element ref="trigger" minOccurs="0"/>
        <xs:element ref="disturb" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="device" use="optional" type="xs:string"/>
      <xs:attribute name="state" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="active"/>
            <xs:enumeration value="idle"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="baseconfig" type="xs:string">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Base Configuration</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
  </xs:element>

  <xs:element name="analogconfig">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Analog Configuration</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="resistor" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="resistor">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Resistor Configuration</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:simpleContent>
        <xs:extension base="xs:string">
          <xs:attribute name="id" use="required">
            <xs:simpleType>
              <xs:restriction base="xs:NMTOKEN">
                <xs:enumeration value="RSH"/>
                <xs:enumeration value="RSL"/>
                <xs:enumeration value="RHL"/>
                <xs:enumeration value="RH"/>
                <xs:enumeration value="RL"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>

  <xs:element name="digitalconfig">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Digital Configuration</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="btr0"/>
        <xs:element ref="btr1"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="btr0" type="xs:string">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">BTR0</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
  </xs:element>

  <xs:element name="btr1" type="xs:string">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">BTR1</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
  </xs:element>

  <xs:element name="trigger">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Trigger</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="canmsg"/>
        <xs:element ref="range_msg"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="range_msg">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Message Range</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="canmsg"/>
        <xs:element ref="canmsg"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="disturb">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Disturbance</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:choice>
        <xs:element ref="limited_number"/>
        <xs:element ref="unlimited_number"/>
        <xs:element ref="continuous"/>
      </xs:choice>
    </xs:complexType>
  </xs:element>

  <xs:element name="limited_number">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Limited Number</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="bitsequence" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="count" use="required" type="xs:string"/>
      <xs:attribute name="cycles" use="optional" type="xs:string"/>
      <xs:attribute name="cyclepause" use="optional" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="unlimited_number">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Unlimited Number</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="bitsequence" minOccurs="0"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="continuous">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Continuous</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="mode" use="required">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="until_stop"/>
            <xs:enumeration value="time_limited"/>
            <xs:enumeration value="while_trigger"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="type" use="required">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
             <xs:enumeration value="analog"/>
            <xs:enumeration value="dominant"/>
            <xs:enumeration value="recessive"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="duration" use="optional" type="xs:string"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="bitsequence">
    <xs:annotation>
      <xs:documentation xml:lang="en">Parameter of CANstress test pattern.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">Bit Sequence</ai:name></ai:username>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:simpleContent>
        <xs:extension base="xs:string">
          <xs:attribute name="resolution" use="optional">
            <xs:simpleType>
              <xs:restriction base="xs:NMTOKEN">
                <xs:enumeration value="Bit"/>
                <xs:enumeration value="BTL"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>

  <xs:element name="canstress_state">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern: Start again last CANstress configuration.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">CANstress State</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="CAN"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="device" use="optional" type="xs:string"/>
      <xs:attribute name="state" use="required">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="idle"/>
            <xs:enumeration value="active"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="fblocksexistence">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern (MOST specific): Verify existence of FBlocks in device.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST FBlock Existence</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="inlist" minOccurs="0"/>
        <xs:element ref="outlist" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="sut" use="required" type="xs:string"/>
      <xs:attribute name="channel" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="timeout" use="required" type="xs:string"/>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="verifynetblock" use="required">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="yes"/>
            <xs:enumeration value="no"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="netblockcomplete">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern (MOST specific): Check if NetBlock corresponds to FBlocks in device.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST NetBlock Complete</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="exceptionlist" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="sut" use="required" type="xs:string"/>
      <xs:attribute name="channel" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="timeout" use="required" type="xs:string"/>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="functionsinfblock">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern (MOST specific): Check given FktIDs for existence in FBlock.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST Functions in FBlock</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="inlist" minOccurs="0"/>
        <xs:element ref="exceptionlist" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="sut" use="required" type="xs:string"/>
      <xs:attribute name="channel" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="timeout" use="required" type="xs:string"/>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="fblock" use="required" type="xs:string"/>
      <xs:attribute name="instance" use="optional" type="xs:string"/>
      <xs:attribute name="usefcat" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="yes"/>
            <xs:enumeration value="no"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="match" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="exact"/>
            <xs:enumeration value="subset"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="genericfblocktest">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern (MOST specific): Performs generic FBlock test from MOST Compliance Test Specification V1.0.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST Generic FBlock Test</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="sut" use="required" type="xs:string"/>
      <xs:attribute name="channel" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="fblock" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="isproperty">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern (MOST specific): Verifies the assumption of a given function to be a property.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">MOST Is Property</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="MOST"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name="sut" use="required" type="xs:string"/>
      <xs:attribute name="channel" use="optional" type="xs:string"/>
      <xs:attribute name="bus" use="optional" type="xs:string"/>
      <xs:attribute name="timeout" use="required" type="xs:string"/>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="fblock" use="required" type="xs:string"/>
      <xs:attribute name="instance" use="optional" type="xs:string"/>
      <xs:attribute name="function" use="required" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_command_response">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern (J1939 specific): send command and wait for response.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Command Response</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="command" minOccurs="0"/>
        <xs:element ref="response" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="timeout" use="optional" type="xs:string"/>
      <xs:attribute name="enableTP" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="0"/>
            <xs:enumeration value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_request_response">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern (J1939 specific): send request and wait for response.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Request Response</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="j1939_pg" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="request" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="specific"/>
            <xs:enumeration value="global"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="timeout" use="optional" type="xs:string"/>
      <xs:attribute name="expect" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="response"/>
            <xs:enumeration value="NACK"/>
            <xs:enumeration value="PACK"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="enableTP" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="0"/>
            <xs:enumeration value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_request_ACL">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern (J1939 specific): Request ACL.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Request ACL</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="j1939_node" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="timeout" use="optional" type="xs:string"/>
      <xs:attribute name="allowNonConfiguredNodes" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="0"/>
            <xs:enumeration value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="allowDifferentAddress" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="0"/>
            <xs:enumeration value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="request" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="global"/>
            <xs:enumeration value="specific"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="requestSA" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_conflict_ACL">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern (J1939 specific): Conflict ACL.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 ACL Conflict</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="j1939_node" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="timeout" use="optional" type="xs:string"/>
      <xs:attribute name="priority" use="optional">
        <xs:simpleType>
          <xs:restriction base="xs:NMTOKEN">
            <xs:enumeration value="lower"/>
            <xs:enumeration value="higher"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name="expectSA" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="j1939_commanded_address">
    <xs:annotation>
      <xs:documentation xml:lang="en">Test pattern (J1939 specific): Command address.</xs:documentation>
      <xs:appinfo>
        <ai:username><ai:name lang="en">J1939 Commanded Address</ai:name></ai:username>
        <ai:classification class="pattern"/>
        <ai:availability>
          <ai:bussystem name="J1939"/>
        </ai:availability>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="j1939_node" minOccurs="0"/>
      </xs:sequence>
      <xs:attribute name="title" use="required" type="xs:string"/>
      <xs:attribute name="timeout" use="optional" type="xs:string"/>
      <xs:attribute name="caSA" use="optional" type="xs:string"/>
      <xs:attribute name="newSA" use="optional" type="xs:string"/>
      <xs:attribute name="variants" use="optional" type="xs:NMTOKENS"/>
    </xs:complexType>
  </xs:element>

</xs:schema>