ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
ETSI Standard
Methods for Testing and Specification (MTS);
The Testing and Test Control Notation version 3;
Part 9: Using XML Schema with TTCN-3
2
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Reference
DES/MTS-xxx
Keywords
MTS, Testing, TTCN, XML
ETSI
650 Route des Lucioles
F-06921 Sophia Antipolis Cedex - FRANCE
Tel.: +33 4 92 94 42 00 Fax: +33 4 93 65 47 16
Siret N° 348 623 562 00017 - NAF 742 C
Association à but non lucratif enregistrée à la
Sous-Préfecture de Grasse (06) N° 7803/88
Important notice
Individual copies of the present document can be downloaded from:
http://www.etsi.org
The present document may be made available in more than one electronic version or in print. In any case of existing or
perceived difference in contents between such versions, the reference version is the Portable Document Format (PDF).
In case of dispute, the reference shall be the printing on ETSI printers of the PDF version kept on a specific network drive
within ETSI Secretariat.
Users of the present document should be aware that the document may be subject to revision or change of status.
Information on the current status of this and other ETSI documents is available at http://www.etsi.org/tb/status/
If you find errors in the present document, send your comment to:
[email protected]
Copyright Notification
No part may be reproduced except as authorized by written permission.
The copyright and the foregoing restriction extend to reproduction in all media.
© European Telecommunications Standards Institute 2005.
All rights reserved.
ETSI
3
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Contents
1
Scope ........................................................................................................................................................ 6
2
References ................................................................................................................................................ 6
3
Abbreviations ........................................................................................................................................... 7
4
Introduction .............................................................................................................................................. 8
5
Mapping XML Schemas .......................................................................................................................... 9
5.1
5.2
5.3
6
6.1
6.1.1
6.1.2
6.1.3
6.1.4
6.1.5
6.1.6
6.1.7
6.1.8
6.1.9
6.1.10
6.1.11
6.2
6.2.1
6.2.2
6.2.3
6.2.4
6.2.5
6.2.6
6.2.7
6.2.8
6.2.9
6.2.10
6.2.11
6.2.12
6.2.13
6.2.14
6.3
6.3.1
6.3.2
6.3.3
6.3.4
6.3.5
6.3.6
6.3.7
6.3.8
6.3.9
6.3.10
6.3.11
6.3.12
6.3.13
6.4
6.4.1
6.4.2
6.4.3
6.5
6.5.1
6.5.2
Namespaces and document references ............................................................................................................. 11
Identifier name conversion .............................................................................................................................. 13
Unsupported features ....................................................................................................................................... 15
Built-in data types .................................................................................................................................. 16
Mapping of facets ............................................................................................................................................ 16
length .......................................................................................................................................................... 17
minLength .................................................................................................................................................. 17
maxLength ................................................................................................................................................. 18
pattern......................................................................................................................................................... 18
enumeration ................................................................................................................................................ 19
whiteSpace ................................................................................................................................................. 20
minInclusive ............................................................................................................................................... 20
maxInclusive .............................................................................................................................................. 20
minExclusive .............................................................................................................................................. 21
maxExclusive ............................................................................................................................................. 21
totalDigits ................................................................................................................................................... 21
String types ...................................................................................................................................................... 22
string........................................................................................................................................................... 22
normalizedString ........................................................................................................................................ 22
token ........................................................................................................................................................... 22
Name .......................................................................................................................................................... 23
NMTOKEN ................................................................................................................................................ 23
NCName..................................................................................................................................................... 23
ID ............................................................................................................................................................... 23
IDREF ........................................................................................................................................................ 23
ENTITY ..................................................................................................................................................... 23
hexBinary ................................................................................................................................................... 23
base64Binary .............................................................................................................................................. 24
anyURI ....................................................................................................................................................... 24
language ..................................................................................................................................................... 25
NOTATION ............................................................................................................................................... 25
Integer types..................................................................................................................................................... 25
integer......................................................................................................................................................... 25
positiveInteger ............................................................................................................................................ 25
nonPositiveInteger ...................................................................................................................................... 25
negativeInteger ........................................................................................................................................... 25
nonNegativeInteger .................................................................................................................................... 25
long............................................................................................................................................................. 26
unsignedLong ............................................................................................................................................. 26
int ............................................................................................................................................................... 26
unsignedInt ................................................................................................................................................. 26
short ............................................................................................................................................................ 26
unsignedShort ............................................................................................................................................. 26
byte ............................................................................................................................................................. 26
unsignedByte .............................................................................................................................................. 27
Float types ........................................................................................................................................................ 27
decimal ....................................................................................................................................................... 27
float............................................................................................................................................................. 27
double ......................................................................................................................................................... 27
Time types ....................................................................................................................................................... 27
duration ...................................................................................................................................................... 27
dateTime..................................................................................................................................................... 27
ETSI
4
6.5.3
6.5.4
6.5.5
6.5.6
6.5.7
6.5.8
6.5.9
6.6
6.6.1
6.6.2
6.6.3
6.6.4
6.7
6.8
7
7.1
7.1.1
7.1.2
7.1.3
7.1.4
7.1.5
7.1.6
7.1.7
7.1.8
7.1.9
7.1.10
7.2
7.3
7.4
7.5
7.5.1
7.5.2
7.5.3
7.6
7.6.1
7.6.1.1
7.6.1.2
7.6.2
7.6.2.1
7.6.2.2
7.6.3
7.6.4
7.6.5
7.6.5.1
7.6.5.2
7.6.5.3
7.6.5.4
7.6.5.5
7.6.6
7.6.6.1
7.6.6.2
7.6.6.3
7.6.6.4
7.6.6.5
7.6.7
7.7
7.8
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
time............................................................................................................................................................. 28
date ............................................................................................................................................................. 28
gYearMonth ............................................................................................................................................... 28
gYear .......................................................................................................................................................... 28
gMonthDay ................................................................................................................................................ 28
gDay ........................................................................................................................................................... 28
gMonth ....................................................................................................................................................... 28
Sequence types................................................................................................................................................. 29
NMTOKENS.............................................................................................................................................. 29
IDREFS ...................................................................................................................................................... 29
ENTITIES .................................................................................................................................................. 29
QName ....................................................................................................................................................... 29
Boolean type .................................................................................................................................................... 30
anyType, anySimpleType types ...................................................................................................................... 30
Mapping XSD components .................................................................................................................... 31
Attributes of XSD component declarations ..................................................................................................... 31
id ................................................................................................................................................................ 32
ref ............................................................................................................................................................... 32
name ........................................................................................................................................................... 32
minOccurs and maxOccurs ........................................................................................................................ 32
default and fixed ......................................................................................................................................... 33
form ............................................................................................................................................................ 34
type ............................................................................................................................................................. 34
mixed .......................................................................................................................................................... 34
abstract ....................................................................................................................................................... 34
block and final ............................................................................................................................................ 34
schema component ........................................................................................................................................... 34
element component .......................................................................................................................................... 34
attribute components ........................................................................................................................................ 35
simpleType components .................................................................................................................................. 36
Derivation by restriction ............................................................................................................................. 37
Derivation by list ........................................................................................................................................ 37
Derivation by union .................................................................................................................................... 38
complexType components ............................................................................................................................... 39
complexType containing simpleContent .................................................................................................... 39
Extending simpleContent ..................................................................................................................... 39
Restricting simpleContent .................................................................................................................... 40
complexType containing complexContent ................................................................................................. 40
Extending complexContent .................................................................................................................. 40
Restricting complexContent ................................................................................................................. 42
group components ...................................................................................................................................... 42
all content ................................................................................................................................................... 43
choice content............................................................................................................................................. 43
choice with nested element ................................................................................................................... 43
choice with nested group ...................................................................................................................... 44
choice with nested choice ..................................................................................................................... 44
choice with nested sequence ................................................................................................................. 45
choice with nested any .......................................................................................................................... 46
sequence content ........................................................................................................................................ 46
sequence with nested element content .................................................................................................. 46
sequence with nested group content ..................................................................................................... 47
sequence with nested choice content .................................................................................................... 47
sequence with nested sequence content ................................................................................................ 48
sequence with nested any content ......................................................................................................... 49
attributeGroup components ........................................................................................................................ 49
any, anyAttribute ............................................................................................................................................. 50
annotation ........................................................................................................................................................ 52
Annex A (normative): XSDAUX.ttcn3 XSD.ttcn3 .......................................................................................... 53
Annex B (informative): Examples .................................................................................................................... 57
Example 1
Example 2
57
60
ETSI
5
Example 3
Example 4
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
62
64
Annex C (normative): List of reserved keywords ............................................................................................ 65
Annex D (normative): List and specification of encoding extension attributes ............................................... 66
Annex E (informative): History........................................................................................................................ 67
ETSI
6
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Intellectual Property Rights
IPRs essential or potentially essential to the present document may have been declared to ETSI. The information
pertaining to these essential IPRs, if any, is publicly available for ETSI members and non-members, and can be found
in ETSI SR 000 314: "Intellectual Property Rights (IPRs); Essential, or potentially Essential, IPRs notified to ETSI in
respect of ETSI standards", which is available from the ETSI Secretariat. Latest updates are available on the ETSI Web
server (http://www.etsi.org/ipr).
Pursuant to the ETSI IPR Policy, no investigation, including IPR searches, has been carried out by ETSI. No guarantee
can be given as to the existence of other IPRs not referenced in ETSI SR 000 314 (or the updates on the ETSI Web
server) which are, or may be, or may become, essential to the present document.
1
Scope
The present document defines the mapping rules for W3C Schema (as defined in [5, 6]) to TTCN-3 (as defined in ES
201 873-1 [1]) to enable testing of XML-based systems, interfaces and protocols. It is part 9 of a multi-part deliverable
covering the Testing and Test Control Notation version 3, as identified below:
Part 1:
"TTCN-3 Core Language";
Part 2:
"TTCN-3 Tabular presentation Format (TFT)";
Part 3:
"TTCN-3 Graphical presentation Format (GFT)";
Part 4:
"TTCN-3 Operational Semantics";
Part 5:
"TTCN-3 Runtime Interface (TRI)";
Part 6:
"TTCN-3 Control Interface (TCI)";
Part 7:
"Using ASN.1 with TTCN-3";
Part 8:
"Using IDL with TTCN-3";
Part 9:
"Using XML Schema with TTCN-3";
Part 10:
"Using C/C++ with TTCN-3".
The specification of other mappings is outside the scope of the present document.
This ETSI Standard (ES) has been produced by ETSI Technical Committee Methods for Testing and Specification
(MTS).
2
References
For the purpose of this ETSI Standard (ES) the following references apply:
[1]
ETSI ES 201 873-1: 2005-06 2007-02, "Methods for Testing and Specification (MTS); The
Testing and Test Control Notation version 3; Part 1: TTCN-3 Core Language", Version 3.1.1
3.2.1
[2]
W3C XML: 2004, Extensible Markup Language (XML) 1.1, W3C Recommendation, World Wide
Web Consortium, http://www.w3.org/TR/xml11.
[3]
W3C XML Namespaces: 1999, Namespaces in XML, W3C Recommendation, World Wide Web
Consortium, http://www.w3.org/TR/1999/REC-xmlnames-19990114,
http://www.w3.org/XML/Schema
[4]
W3C XML Schema: 2004, XML Schema Part 0: Primer, W3C Recommendation, World Wide
Web Consortium, http://www.w3.org/TR/xmlschema-0
[5]
W3C XML Schema: 2004, XML Schema Part 1: Structures, W3C Recommendation, World Wide
Web Consortium, http://www.w3.org/TR/xmlschema-1
ETSI
7
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
[6]
W3C XML Schema: 2004, XML Schema Part 2: Datatypes, W3C Recommendation, World Wide
Web Consortium, http://www.w3.org/TR/xmlschema-2
[7]
IETF RFC 3986: 2005, "Uniform Resource Identifiers (URI): Generic Syntax"
[8]
W3C SOAP version 1.2 Specification: 2003, W3C Recommendation, World Wide Web
Consortium, http://www.w3.org/TR/soap12
[9]
I. Schieferdecker, B. Stepien: Automated Testing of XML/SOAP based Web Services, 13.
Fachkonferenz der Gesellschaft für Informatik (GI) Fachgruppe "Kommunikation in verteilten
Systemen" (KiVS), Leipzig, 26.-28. Feb. 2003.
[10]
Dafina Maria Jeaca: XML Schema to TTCN-3 Mapping: Importing XMLSchema datatypes into
TTCN-3, MSc Thesis, Politehnica University of Bucharest, Department of Computer Science,
September 2004.
[11]
W3C Information technology – ASN.1 encoding rules – mapping W3C XML schema definitions
into ASN.1 ITU-T X.694
[12]
W3C Information technology – ASN.1 encoding rules – XML encoding rules ITU-T X.693
[13]
W3C Information technology – ASN.1 encoding rules – XML encoding rules Amendment 1 to
ITU-T X.693
3
Abbreviations
For the purpose of the present document, the following abbreviations apply:
ASN.1
TTCN-3
URI
W3C
XML
XSD
SOAP

Abstract Syntax Notation One
Testing and Test Control Notation
IETF Uniform Resource Identifier
World Wide Web Consortium
W3C Extensible Markup Language
W3C XML Schema
Simple Object Access Protocol
The whitespace character
ETSI
8
4
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Introduction
An increasing number of distributed applications use the XML format to exchange data for various purposes like data
bases queries or updates or event telecommunications operations such as provisioning. All of these data exchanges
follow very precise rules for data format description in the form of Document Type Description (DTD) [2, 3] or more
recently the proposed XML Schemas [4, 5, 6]. There are even some XML based communication protocols like SOAP
[8] that are based on XML Schemas. Like any other communication-based systems, components and protocols, XML
based systems, components and protocols are candidates for testing using TTCN-3 [1]. Consequently, there is a need for
establishing a mapping between XML data description techniques like DTD or Schemas to TTCN-3 standard data
types.
The core language of TTCN-3 is defined in ES 201 873-1 [1] and provides a full text-based syntax, static semantics and
operational semantics as well as a definition for the use of the language with ASN.1 in part 7 of the standard. The XML
mapping provides a definition for the use of the core language with XML Schema structures and types, enabling
integration of XML data with the language as shown in Figure 1.
ASN.1 Types
& Values
TTCN-3
Core
Language
Tabular
format
XSD Types
Graphical
format
Other Types
& Values n
Presentation
formatn
TTCN-3 User
The shaded boxes are not
defined in this document
Figure 1: User's view of the core language and the various presentation formats
ETSI
9
5
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Mapping XML Schemas
There are two approaches to the integration of XML Schema and TTCN-3, which will be referred to as implicit and
explicit mapping. The implicit mapping makes use of the import mechanism of TTCN-3, denoted by the keywords
language and import. It facilitates the immediate use of data specified in other languages. Therefore, the definition of a
specific data interface for each of these languages is required. The explicit mapping translates XML Schema definitions
directly into appropriate TTCN-3 language artefacts.
In case of an implicit mapping an internal representation is produced from the XML Schema, which representation
should retain all the structural and encoding information. This internal representation is not accessible by the user.
For explicit mapping, the information present in the XML Schema is mapped into accessible TTCN-3 code and - the
XML structural information which does not have its correspondent in TTCN-3 code - into accesible encoding
instructions.
The present document defines the mapping rules that have to be used by both of the approaches. XML DTDs need to be
translated first into XML Schema before being mapped to TTCN-3. This may be done easily using available free or
commercial tools.
The examples of this document are written in the assumption explicit mapping, although the difference is mainly in
accessibility and visibility of generated TTCN-3 code and encoding instruction set.
The ITU recommendation X.694, published in 2004, describes mapping of XML Schema definitions into ASN.1 and EXER encoding instructions (standardized in the ITU recommendation X.693 amendment 1, published a year earlier).
This standard, describing direct usage of XML from TTCN-3, should offer compatibility with the above solution,
helping seamless migration from the ASN.1 based implementations to TTCN-3 based ones.
To migrate from an ITU-T Rec. X.694 based hybrid solution, where TTCN-3 message templates are written against
ASN.1 code converted from XML Schema, to an entirely TTCN-3 based solution, the TTCN-3 type definitions plus
the encoding extensions should replace the previously used ASN.1 plus E-XER encoding instructions without a
significant impact on the rest of the TTCN-3 implementation (TTCN-3 templates especially) and on the produced XML
documents.
For compatibility, the TTCN-3 code obtained from the XML Schema using this standard for an explicit mapping should
be the same (while for an implicit mapping should have the same view) as the TTCN-3 code obtained from first
converting the XML Schema using ITU-T Rec. X.694 into ASN.1 then converting the resulting ASN.1 into TTCN-3
code using ETSI 873-7. Moreover, the XML document produced by the TTCN-3 code with encoding extensions
obtained from the XML Schema based on this standard (both for an explicit and implicit mapping) should be the same
as the XML document produced by the ASN.1 with E-XER encoding based on ITU-T Rec. X.694 conversion of the
same XML Schema.
This document is structured in two distinct parts:
Chapter 6 “
ETSI
10
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Built-in data types” defines the TTCN-3 mapping for all basic XSD data types like strings (see clause 6.2), integers (see
clause 6.3), floats (see clause 6.4), etc. and facets (see clause 6.1) that allow for a simple modification of types by
restriction of their properties (e.g. restricting the length of a string or the range of an integer).
Chapter 7 “
ETSI
11
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Mapping XSD components” covers the translation of more elaborate structures that are formed using the components
shown in Table 1 and a set of XSD attributes (see clause 7.1) which allow for modification of constraints of the
resulting types.
Table 1: Overview of XSD constructs
5.1
Element
Defines tags that can appear in a conforming XML document.
attribute
Defines attributes for element tags in a conforming XML document.
simpleType
Defines the simplest types. They may be a built-in type, a list or choice of
built-in types and they are not allowed to have attributes.
complexType
Defines types that are allowed to be composed, e.g. have attributes and an
internal structure.
named model group
Defines a named group of elements.
attribute group
Defines a group of attributes that can be used as a whole in definitions of
complexTypes.
identity constraint
Defines that a component has to exhibit certain properties in regard to
uniqueness and referencing.
Namespaces and document references
A single XSD Schema will be translated to a single TTCN-3 Module. A single XSD Schema will be translated to one
ore more TTCN-3 modules, corresponding to schema components that have the same target namespace. Any XSD
include / import statements are mapped to equivalent TTCN-3 import statements. An XSD Schema including another
XSD Schema will be translated to two TTCN-3 modules , one importing from the other, both having the same target
namespace. The module names generated by the translation are not standardized.
XML namespaces are supported only by means of incorporating any namespace qualifiers into the translated TTCN-3
identifier, as TTCN-3 does not offer a namespace concept. To do this, a translator has to first bring all XSD identifers to
a unique qualified form (e.g. by evaluating the targetNamespace, elementFormDefault, and attributeFormDefault
attributes of the XSD schema component and the xmlns and name attribute of every XSD component and combining
them to a identifiers which are unique across all used schemas) and than translate these unique qualified names to
TTCN-3 identifiers as described in clause 5.2.
As TTCN-3 does not offer a namespace concept, information about namespaces and prefixes (from targetNamespace,
elementFormDefault, attributeFormDefault etc.) will be preserved not in the TTCN-3 code but in the encoding
extensions (internal or external). To allow this, an extension permitting explicit specification of the namespaces and
prefixes is introduced:
module MyModule
{
:
} with {
encode “XML”;
variant “namespace all, all in all as ‘http://www.example.org/’ prefix ‘ns0’”
}
All types declared in the module will inherit the namespace declaration of the module. This can be overridden by
namespace declarations qualifying fields of declared structures:
ETSI
12
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Example:
module MyModule
{
:
type record MyRecordType
{
integer
field1,
charstring
field2
}
with {
variant (field1) “namespace
}
:
as ‘http://www.example.org/example1’ prefix ‘ns1’”;
} with {
encode “XML”;
variant “namespace all, all in all as ‘http://www.example.org/’ prefix ‘ns0’”
}
template MyRecordType
{
field1 := 3,
field2 := “four”
}
MyTemplate
:=
will be encoded as:
<?xml version=”1.0” encoding=”UTF-8”?>
<ns0:MyRecordType xmlns:ns0=http://www.example.org/>
< ns1:field1 xmlns:ns1=http://www.example.org/example1>3</ns1:field1>
< ns0:field2>four</ ns0:field2>
</ns0:MyRecordType>
If a module has no namespace declaration, all types and fields of types declared within the module are assumed to have
no namespace ,except when a qualifying statement refers a declared type or field directly.
The importation structure of the TTCN-3 modules will retain the importation structure of the imported XML schemas.
TTCN-3 ‘import’ statements will import types declared in other modules, and referrenced in the current module.
The control namespace ( the namespace of the type identification attributes and of the nil identification attribute) will
be specified globally , with an encoding extension attached to the TTCN-3 module:
module MyModule
{
:
} with {
encode “XML”;
variant “controlNamespace ‘http://www.w3.org/2001/XMLSchema-instance’ prefix ‘xsi’”
}
Qualifying declarations of the namespace prefixes can be used against templates, allowing re-declaration of namespace
prefixes inherited from the referred types:
template MyRecordType
MyTemplate2 :=
{
field1 := 3,
field2 := “four”
} with {
encode “XML”;
variant (field1) “namespace prefix ‘newns1’”;
variant (field2) “namespace prefix ‘newns0’”
}
will be encoded as:
ETSI
13
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
<?xml version=”1.0” encoding=”UTF-8”?>
<newns0:MyRecordType xmlns:newns0=http://www.example.org/>
<newns1:field1 xmlns:newns1=http://www.example.org/example1>3</newns1:field1>
<newns0:field2>four</newns0:field2>
</newns0:MyRecordType>
For reception templates , wildcards (*,?) are allowed to be used in the prefix declaration.
For sake of clarity , wherever irrelevant, namespaces have been omitted from all most of the examples in this
document.
5.2
Identifier name conversion
Translation of identifiers (e.g. type or field names) has a critical impact on the usability of conversion results: primarily,
it must guarantee TTCN-3 consistency, but , in order to support migration of conversion results from code generated
with tools based on ITU-T Rec. X.694, it must also generate identifiers compatible with that standard. It must also
support portability of conversion results (the TTCN-3 code and the encoding instruction set) between TTCN-3 tools of
different manufacturers, which is only possible if identifier conversion is standardised.
During the translation from XSD to TTCN-3 care has to be exercised when translating identifiers (e.g. type or field
names). For different reasons a valid XSD identifier may not be valid in TTCN-3. For example it would be fine to
specify both an attribute and an element of the same name in XSD. When mapped in a naïve fashion this would result in
two different types with the same name in TTCN-3. A translator must therefore apply a name conversion scheme that
guarantees unique identifier names in TTCN-3. As the name conversion may depend upon a concrete implementation of
the TTCN-3 tool chain (e.g. not all compilers may be able to handle identifiers with prefixed underscores) the name
conversion itself is not standardised.
A name conversion algorithm has to guarantee that the translated identifier name…
a)
is unique within the scope it is to be used
b) contains only valid characters
c)
is not a TTCN-3 keyword
d) is not a reserved word (“base” or “content”)
A translation that satisfies all the above criteria can be obtained with the following algorithm:
1.
First , the transformations described in ch.10 (Name conversion) of recommendation ITU-T Rec. X.694
(Mapping W3C XML Schema definitions into ASN.1) have to be applied; this will result in identifiers
consistent with the ASN.1 standards
2.
Second, the transformations described in ch. 8.2 (Identifiers) of the ETSI standard ES 201 873-7 (Using ASN.1
with TTCN-3) have to be applied; this will result in identifiers both consistent with the TTCN-3 standard and
compatible with conversion results of tools based on ITU-T Rec. X.694
A side effect of this algorithm is the possible distortion of identifiers (e.g. capitalization of type names when
converting to ASN.1). Appropriate encoding instructions will have to control name conversion in the encoder/decoder.
Example(informative):
<xs:element name="e0">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="index" type="xs:integer"/>
</xs:sequence>
</xs:complexType>
</xs:element>
ETSI
14
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Will be translated as:
type record E0
{
charstring
name,
integer
index
}
With no encoding instructions, this will wrongly be encoded as:
<?xml version=”1.0” encoding=”UTF-8”?>
<E0>
<name>name</name>
<index>3</index>
</E0>
Using the “name…as…” encoding instruction, names will be restored at both encoding and decoding:
type record E0
{
charstring
name,
integer
index
}
with {
variant “element”;
variant “name ‘E0’ as uncapitalized”;
}
template E0
MyE0Template
{
name := “name”,
index := 3
}
:=
results in the following encoding:
<?xml version=”1.0” encoding=”UTF-8”?>
<e0>
<name>name</name>
<index>3</index>
</e0>
Global encodings can be specified with encoding instructions attached to the module:
module MyModule
{
:
} with {
encode “XML”;
variant “name all as uncapitalized”
}
All identifiers within the examples of this document use the following algorithm for translation:
1.
If the given type refers to a field:
Then go to rule 3
2.
If the type is not named, has no id or does not references a type with a name:
Then use the name “ANONYM” and a sequential number (e.g. ANONYM1)
Else use the type’s name, id or referenced type’s name
ETSI
15
NOTE:
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
The sequential number needs to be unique per module as anonymous types are not to be
used outside of a module.
3.
If the name is a TTCN-3 keyword or a reserved word:
Then convert the name to uppercase letters
4.
If the type is not an element:
Then postfix name with two underscores and and the type (e.g. foo__attribute)
5.
If the type is defined in a namespace:
Then prefix the name with the namespace’s name and an underscore (e.g. ns_foo)
5.3
Unsupported features
XSD and TTCN-3 are very distinct languages. Therefore some features of XSD have no equivivalent
equivalent in TTCN-3 or make no sense when translated to the TTCN-3 language. Whenever possible,
these features are translated into encoding instructions completing the TTCN-3 code. The following list
contains a compilation of these unsupported features.
a)
Numeric types are not allowed to be restricted by patterns.
b) List types are not allowed to be restricted by enumerations or patterns.
c)
Specifying the number of fractional digits for float types is not supported.
d) Mixed content is not supported.
e)
Translation of the form attribute is not supported.
f)
Translation of the abstract attribute is not supported.
g) Translation of the block attribute is not supported.
h) Translation of the final attribute is not supported.
i)
All time types (see clause 6.5) restrict year to 4 digits.
ETSI
16
6
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Built-in data types
Built-in datatypes may be primitive or derived types. The latter are gained from primitive types by means of a
restriction mechanism called facets. For the mapping of primitive types, a specific TTCN-3 module XSDAUX XSD is
provided which defines the relation of XSD primitive types to TTCN-3 types. The capitalized type names used in
Annex A of ITU-T Rec. X.694 have been retained for compatibility. All translated structures are the result of two
subsequent transformations applied to the XSD Schema: first , transformations descibed in ITU-T Rec.X.694 , then
transformations described in ETSI standard ES 201 873-7. In addition, specific extensions are used that allow codecs to
keep track of the original XSD nature of a given TTCN-3 type.
Whenever a new simpleType is defined, with the base type a built-in one, it will be mapped directly from types defined
in XSDAUX XSD:
Example:
<simpleType name="e1">
<restriction base="integer"/>
</simpleType>
Becomes
type XSDAUX.integer_ e1__simpleType;
type XSD.Integer E1
with {
variant “name ‘E1’ as uncapitalized ”;
};
In the following clauses both the principle mappings of facets and the translation of primitive types are given. The
complete content of the XSDAUX XSD module is given in Annex A.
6.1
Mapping of facets
Table 2 summarises the facets for the built-in types that are supported in TTCN-3. Some of them may be supported in
XML Schema but have no counterpart in TTCN-3 and therefore no mark in this table.
Table 2: Mapping support for facets of built-in types
facet
length
type
string

min
max
pattern enum.
Length Length

(Note 1)(Note 1)


(Note 1)
(Note 2)
min
Incl.
max
Incl.
min
Excl.
max
Excl.
total
Digits


(Note 3)
integer






float





(Note 4)

time
list


white
Space







boolean
NOTE 1: With the exception of QName which does not support length restriction.
NOTE 2: With the exception of hexBinary which does not support patterns.
NOTE 3: With the exception of some types (see clause 6.1.6).
NOTE 4: With the exception of decimal which does support totalDigits.
ETSI
17
6.1.1
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
length
The facet length describes, how many units of length a value of the given simple type must have. For string and
datatypes derived from string, length is measured in units of characters. For hexBinary and base64Binary and datatypes
derived from them, length is measured in octets (8 bits) of binary data. For datatypes derived by list, length is measured
in number of list items. A length-restricted XSD type is mapped to a corresponding length restricted type in TTCN-3,
e.g.
<simpleType name="e2">
<restriction base="string">
<length value="10"/>
</restriction>
</simpleType>
Is translated to the following TTCN-3 type
type XSDAUX.string e2__simpleType length(10);
type XSD.String E2 length(10)
with {
variant “name ‘E2’ as uncapitalized”;
};
For built-in list types (see clause 6.6) the number of elements of the resulting set structure will be restricted. For
example consider the following translation:
<simpleType name="e3">
<restriction base="NMTOKENS">
<length value="10"/>
</restriction>
</simpleType>
Mapped to TTCN-3:
type set length(10) of NMTOKEN e3__simpleType;
type NMTOKENS E3 length(10)
with {
variant “name ‘E3’ as uncapitalized”;
};
6.1.2
minLength
The facet minLength describes, how many units of length a value of the given simple type at least must have. It is
mapped to a length restriction in TTCN-3 with a set lower boundary and an open upper boundary. Usage of the
attribute fixed (see clause 7.1.5) has to be ignored. Consider this example:
<simpleType name="e4">
<restriction base="string">
<minLength value="3"/>
</restriction>
</simpleType>
Is translated to
type XSDAUX.string e4__simpleType length(3 .. infinity);
type XSD.String E4 length(3 .. infinity)
with {
variant “name ‘E4’ as uncapitalized”;
};
ETSI
18
6.1.3
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
maxLength
The facet maxLength describes, how many units of length a value of the given simple type at most must have. It is
mapped to a length restriction in TTCN-3 with a set upper boundary and a lower boundary of zero. Usage of the
attribute fixed (see clause 7.1.5) has to be ignored. Consider this example:
<simpleType name="e5">
<restriction base="string">
<maxLength value="5"/>
</restriction>
</simpleType>
Is mapped to
type XSDAUX.string e5__simpleType length(0 .. 5);
type XSD.String E5 length(0 .. 5)
with {
variant “name ‘E5’ as uncapitalized”;
};
6.1.4
pattern
The facet pattern describes a constraint in terms of a regular expression applied on a value space of a data type. For
string based types this can be directly translated using the support in TTCN-3 for defining regular expression patterns
on character sequences. It is not supported for numerical or boolean types. As the syntax for regular patterns differs
between XSD and TTCN-3 a mapping of the pattern expression has to be applied. The symbols (, ), |, [, ], ^, - do not
change and are translated directly. For the mapping of all other symbols please refer to Table 3 and Table 4.
Table 3: Translation of special characters
Table 4: Translation of quantifiers
XSD
TTCN-3
XSD
TTCN-3
.
?
?
#(0,1)
\s
[\t\n\r]
+
#(1, )
\S
[^\t\n\t]
*
#(0, )
\d
\d
{n,m}
#(n,m)
\D
[^\d]
{n}
#(n)
\w
\w
{n ,}
#(n, )
\W
[^\w]
\i
[\w\d:]
\I
[^\w\d:]
\c
[\w\d.\-_:]
\C
[^\w\d.\-_:]
Unicode characters in XSD patterns are directly translated but the
syntax changes from &#xgprc; in XSD to \q{g, p, r, c} in
TTCN-3, where g, p, r, and c each represent a single hexadecimal
character. Please note that in TTCN-3 only supports uppercase
letters for hexadecimal characters and requires that all vallues
values have to be are set.
Escaped characters in XSD are mapped to an escaped character in
TTCN-3 or directly to the character (e.g. '.', and '+'). The double
quote character must be mapped to an escaped double quote character. Character categories and blocks (like \p{Lu} or
\p{IsBasicLatin}) are not supported. The correctness of the regular expression mappings themselves should be
checked according to [1] Annex B.1.5. Consider the following example:
<simpleType name="e6">
<restriction base="string">
<pattern value="(ahi|eho|cre|dve)@(f|F)okus"/>
</restriction>
</simpleType>
ETSI
19
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Will be mapped to the following TTCN-3 expresion:
type XSDAUX.string e6__simpleType (pattern "(ahi|eho|cre|dve)@(f|F)okus");
type XSD.String E6 (pattern "(ahi|eho|cre|dve)@(f|F)okus")
with {
variant “name ‘E6’ as uncapitalized”;
};
6.1.5
enumeration
The facet enumeration constraints the value space to a specified set of values for a type. It is not corresponding to the
enumeration construct in TTCN-3, but will be mapped to a list of supplied values instead, e.g.
For reasons of compatibility with ITU-T Rec. X.694, it will be mapped to a TTCN-3 enumerated type along the
principles described in ch 12.4 (The enumeration facet) of ITU-T Rec. X.694.
Example(informative):
<simpleType name="e7">
<restriction base="string">
<enumeration value="rock"/>
<enumeration value="paper"/>
<enumeration value="scissors"/>
</restriction>
</simpleType>
<simpleType name="e7">
<restriction base="string">
<enumeration value="Rock"/>
<enumeration value="Paper"/>
<enumeration value="Scissors"/>
</restriction>
</simpleType>
Is mapped to:
type XSDAUX.string e7__simpleType ("rock", "paper", "scissors");
type enumerated E7 {rock,paper,scissors}
with {
variant “text all as capitalized”;
variant “name ‘E7’ as uncapitalized”;
}
While
<simpleType name="e7a">
<restriction base="integer">
<enumeration value="0"/>
<enumeration value="5"/>
<enumeration value="10"/>
</restriction>
</simpleType>
Is mapped to:
type enumerated E7a {int0,int5,int10}
with {
variant “useNumber”;
variant “name ‘E7a’ as uncapitalized”;
};
This mapping is done similar for other types (e.g. numerical types).
ETSI
20
6.1.6
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
whiteSpace
The whiteSpace facet has no corresponding feature in TTCN-3 but is preserved for the codec using a with-clause
appropriate encoding instructions. For example:
<simpleType name="e8">
<restriction base="string">
<whiteSpace value="replace"/>
</restriction>
</simpleType>
This can be mapped into a charstring, sending information about the whiteSpace facet to the codec.
type XSDAUX.string e8__simpleType with {
type XSD.String E8
with {
variant "whiteSpace replace";
variant “name ‘E8’ as uncapitalized”;
};
For most built-in types the value of the whiteSpace facet is set to “collapse”, only the string type normalizedString (see
clause 6.2.2), token (see clause Error! Reference source not found.), language (see clause 6.2.13), Name (see clause
6.2.4) and NCName (see clause 6.2.6) are allowed to specify this facet.
6.1.7
minInclusive
The minInclusive facet is only valid for numerical types. It specifies the lowest bound for a number, including the
boundary. This is mapped to a range restriction in TTCN-3 with a given lower boundary and the upper boundary of the
base type (or infinity if not set). Consider the following example:
Mapping of elements of type integer with minInclusive facet:
<simpleType name="e9">
<restriction base="integer">
<minInclusive value="-5"/>
</restriction>
</simpleType>
Is mapped to
type XSDAUX.integer_ e9__simpleType (-5 .. infinity);
type XSD.Integer E9 (-5 .. infinity)
with {
variant “name ‘E9’ as uncapitalized”;
};
6.1.8
maxInclusive
The maxInclusive facet is only valid for numerical types. It specifies the upmost bound for a number, including the
boundary. This is mapped to a range restriction in TTCN-3 with a given upper boundary and the lower boundary of the
base type (-infinity if not set). Consider the following example:
Mapping of elements of type integer with minInclusive facet:
<simpleType name="e10">
<restriction base="positiveInteger">
<maxInclusive value="100"/>
</restriction>
</simpleType>
Is mapped to
type XSDAUX.positiveInteger e10__simpleType (1 .. 100);
type XSD.PositiveInteger E10 (1 .. 100)
with {
variant “name ‘E10’ as uncapitalized”;
};
ETSI
21
6.1.9
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
minExclusive
The mapping of minExclusive is very similar to minInclusive (see clause 6.1.7) only the given bound is not part of the
range. A direct mapping of this is not possible in TTCN-3, as ranges are always including the given boundaries. To get
around this a value delta needs to be defined which is the smallest possible number handled by the TTCN-3 compiler
for a given type (e.g. 1 for integer types and something very small for a double). The boundary is then modified by
adding the delta. Considering the mapping result of the example in clause 6.1.7 a translation with minExclusive facet
would look like:
type XSDAUX.integer_ e11__simpleType (-4 .. infinity);
type XSD.Integer E11 (-4 .. infinity)
with {
variant “name ‘E11’ as uncapitalized”;
};
(The original boundary of -5 has been modified by the addition of a delta of 1).
6.1.10
maxExclusive
The mapping of maxExclusive is very similar to maxInclusive (see clause 6.1.8) only the given bound is not part of the
range. A direct mapping of this is not possible in TTCN-3, as ranges are always including the given boundaries. To get
around this a value delta needs to be defined which is the smallest possible number handled by the TTCN-3 compiler
for a given type (e.g. 1 for integer types and something very small for a double). The boundary is then modified by
subtracting the delta. Considering the mapping result of the example in clause 6.1.8 a translation with maxExclusive
facet would look like:
type XSDAUX.positiveInteger e12__simpleType (1 .. 99);
type XSD.PositiveInteger E12 (1 .. 99)
with {
variant “name ‘E12’ as uncapitalized”;
};
(The original boundary of 100 has been modified by the subtraction of a delta of 1).
6.1.11
totalDigits
This facet defines the total number of digits a numeric value is allowed to have. It is mapped to TTCN-3 using ranges
by converting the value of totalDigits to the proper boundaries of the numeric type in question, e.g.
<simpleType name="e13">
<restriction base="negativeInteger">
<totalDigits value="3"/>
</restriction>
</simpleType>
Will be translated to
type XSDAUX.negativeInteger e13__simpleType (-999 .. -1);
type XSD.NegativeInteger E13 (-999 .. -1)
with {
variant “name ‘E13’ as uncapitalized”;
};
ETSI
22
6.2
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
String types
XSD string types are generally converted to TTCN-3 as subtypes of universal charstring or octetstring. For an
overview of the allowed facets please refer to Table 2 in clause 6.1. Following are details on the mapping of all string
types of XSD.
To support mapping , the following type definitions are added to the built-in datatypes( utf8string is declared as a UTF8 encoded subtype of universal charstring in Annex E2.2.0 of ETSI ES 201 873-1 [1]):
type utf8string XMLCompatibleString
(
char(0,0,0,9).. char(0,0,0,9),
char(0,0,0,10)..char(0,0,0,10),
char(0,0,0,12)..char(0,0,0,12),
char(0,0,0,32)..char(0,0,215,255),
char(0,0,224,0)..char(0,0,255,253),
char(0,1,0,0)..char(0,16,255,253)
)
type utf8string XMLStringWithNoWhitespace
(
char(0,0,0,33)..char(0,0,215,255),
char(0,0,224,0)..char(0,0,255,253),
char(0,1,0,0)..char(0,16,255,253)
)
type utf8string XMLStringWithNoCRLFHT
(
char(0,0,0,32)..char(0,0,215,255),
char(0,0,224,0)..char(0,0,255,253),
char(0,1,0,0)..char(0,16,255,253)
)
6.2.1
string
The string type is translated to TTCN-3 as a plain an XML compatible restriction of the universal charstring in
XSDAUX XSD:
type charstring string XMLCompatibleString String
extension variant "XSD:string"
};
6.2.2
with {
normalizedString
The normalizedString type is translated to TTCN-3 using the following pattern-restricted XML compatible restricted
subtype of the universal charstring in XSDAUX XSD:
type charstring normalizedString XMLStringWithNoCRLFHT NormalizedString (pattern
"[^\n\r\t]#(0,)") with {
extension variant "XSD:normalizedString"
};
6.2.3
token
The token type is translated to TTCN-3 using the following pattern-restricted charstring built-in datatype
NormalizedString in XSDAUX XSD:
type charstring token NormalizedString Token (pattern
"([^\t\r\n]#(1,)([^\t\r\n]#(1,))#(0,))|") with {
extension variant "XSD:token"
};
ETSI
23
6.2.4
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Name
The NAME type is translated to TTCN-3 using the following pattern-restricted XML compatible restricted subtype of
the universal charstring in XSDAUX XSD:
type charstring XMLStringWithNoWhitespace Name (pattern "[\w_:]#(1,)[\w\d_:-.]#(0,)") with {
extension variant "XSD:Name"
};
6.2.5
NMTOKEN
The NMTOKEN type is translated to TTCN-3 using the following pattern-restricted XML compatible restricted subtype
of the universal charstring in XSDAUX XSD:
type charstring XMLStringWithNoWhitespace NMTOKEN (pattern "[\d\w_.:-]#(0,)") with {
extension variant "XSD:NMTOKEN"
};
6.2.6
NCName
The NCNAME type is translated to TTCN-3 using the following pattern-restricted charstring built-in datatype Name in
XSDAUX XSD:
type charstring Name NCName (pattern "[a-zA-Z_]#1[\w_-.]#(0,)") with {
extension variant "XSD:NCName"
};
6.2.7
ID
The ID type is translated to TTCN-3 using the a pattern-restricted charstring built-in datatype NCName in XSDAUX
XSD:
type charstring NCName ID (pattern "[\w_]#(1,)[\w\d_-.]#(0,)") with {
extension variant "XSD:ID"
};
6.2.8
IDREF
The IDREF type is translated to TTCN-3 using the a pattern-restricted charstring built-in datatype NCName in
XSDAUX XSD:
type charstring NCName IDREF (pattern "[\w_]#(1,)[\w\d_-.]#(0,)") with {
extension variant "XSD:IDREF"
};
6.2.9
ENTITY
The ENTITY type is translated to TTCN-3 using the a pattern-restricted charstring built-in datatype NCName in
XSDAUX XSD:
type charstring NCName ENTITY (pattern "[\w_]#(1,)[\w\d_-.]#(0,)") with {
extension variant "XSD:ENTITY"
};
6.2.10
hexBinary
The hexBinary type is translated to TTCN-3 using a plain octetstring in XSDAUX XSD:
type octetstring hexBinary HexBinary with {
extension variant "XSD:hexBinary"
};
A translation has to be aware of the fact that XSD hexBinary allows for the usage of lowercase letters (a, b, c, d, e, and
f) for specification of values. These need to be converted to upper case for TTCN-3.
It is not legal to specify patterns for hexBinary types.
ETSI
24
6.2.11
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
base64Binary
The XSD base64Binary type is translated to a pattern-restricted character string an octetstring in TTCN-3. As
base64Binary is defined on 4-tuples of characters in XSD and charstring is defined on single characters in TTCN-3, a
mapping has to take care of length adjustments (e.g. multiplying by four during translation). It is also necessary to strip
possible trailing equal signs (“=”) from the XSD input before translating, which has implications on the length as well
(a translated character string might be up to three characters shorter than calculated). Please refer to [6], clause 3.2.16
for more information on the specific padding mechanism. When encoding elements of this type, the XML codec will
invoke automatically an appropriate base64 encoder; when decoding XML instance content, the base64 decoder will be
called.
The base64Binary type mapped into TTCN-3 in XSDAUX XSD file is:
type charstring base64Binary (pattern "([0-9]|[a-z]|[A-Z]|\+|/)#(0,)") with {
extension "XSD:base64Binary"
};
type octetstring Base64Binary with {
variant "XSD:base64Binary";
};
Example:
<simpleType name="E14">
<restriction base="base64Binary"/>
</simpleType>
will be translated as:
type XSD.Base64Binary E14
with {
variant “name ‘E14’ as uncapitalized”;
};
and a value:
template E14
MyBase64BinaryTemplate:= '546974616E52756C6573'O
will be encoded as:
<e14>VGl0YW5SdWxlcw==\r\n</e14>
Consider this example regarding length adjustmens with base64Binary types:
<simpleType name="e8">
<restriction base="base64Binary">
<length value="5"/>
</restriction>
</simpleType>
The length needs to be multiplied by four to accommodate the 4-tuples of characters. Together with the length
adjustment for the potentially removed padding this translates to:
type XSDAUX.base64Binary e8__simpleType length(18 .. 20);
6.2.12
anyURI
The anyURI type is containing a URI is translated to TTCN-3 as a plain an XML compatible restricted subtype of the
universal charstring in XSDAUX XSD:
type charstring anyURI XMLStringWithNoCRLFHT AnyURI with {
extension variant "XSD:anyURI"
};
NOTE:
Finding a general pattern to restrict a charstring to all valid URIs may be possible (for the format see [7]),
but the result would be complex, therefore decision was taken against specifying such a pattern.
ETSI
25
6.2.13
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
language
The language type is translated to TTCN-3 using the following pattern-restricted charstring in XSDAUX XSD:
type charstring languageXSD Language (pattern "[a-zA-Z]#(1,8)(-[\w]#(1,8))#(0,)") with {
extension variant "XSD:language"
};
6.2.14
NOTATION
The XSD NOTATION type is not translated to TTCN-3.
6.3
Integer types
XSD integer types are generally converted to TTCN-3 as subtypes of integer-based types. For an overview of the
allowed facets please refer to Table 2 in clause 6.1. Following are details on the mapping of all integer types of XSD.
6.3.1
integer
The integer type is not range-restricted in XSD and translated to TTCN-3 as a plain integer in XSDAUX XSD:
type integer integer_ Integer with {
extension variant "XSD:integer"
};
As “integer” is already a keyword, an underscore has to be appended to the name.
6.3.2
positiveInteger
The positiveInteger type is translated to TTCN-3 as a range-restricted integer in XSDAUX XSD:
type integer positiveInteger PositiveInteger (1 .. infinity) with {
extension variant "XSD:positiveInteger"
};
6.3.3
nonPositiveInteger
The nonPositiveInteger type is translated to TTCN-3 as a range-restricted integer in XSDAUX XSD:
type integer nonPositiveInteger NonPositiveInteger (-infinity .. 0) with {
extension variant "XSD:nonPositiveInteger"
};
6.3.4
negativeInteger
The negativeInteger type is translated to TTCN-3 as a range-restricted integer in XSDAUX XSD:
type integer nonPositiveInteger NegativeInteger (-infinity .. -1) with {
extension variant "XSD:negativeInteger"
};
6.3.5
nonNegativeInteger
The nonNegativeInteger type is translated to TTCN-3 as a range-restricted integer in XSDAUX XSD:
type integer nonNegativeInteger NonNegativeInteger (0 .. infinity) with {
extension variant "XSD:nonNegativeInteger"
};
ETSI
26
6.3.6
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
long
The long type is 64bit based and translated to TTCN-3 as a plain longlong (defined in Annex D.2.1.3 of ETSI ES 201
873-1 [1]) in XSDAUX XSD:
type longlong long_ Long with {
extension variant "XSD:long"
};
As “long” is already a keyword, an underscore has to be appended to the name.
6.3.7
unsignedLong
The unsignedLong type is 64bit based and translated to TTCN-3 as a plain unsignedlonglong (defined in Annex D.2.1.3
of ETSI ES 201 873-1 [1]) in XSDAUX XSD:
type unsignedlonglong unsignedLong UnsignedLong
extension variant "XSD:unsignedLong"
};
6.3.8
with {
int
The int type is 32bit based and translated to TTCN-3 as a plain long (defined in Annex D.2.1.2 of ETSI ES 201 873-1
[1]) in XSDAUX XSD:
type long int Int with {
extension variant "XSD:int"
};
6.3.9
unsignedInt
The unsignedInt type is 32bit based and translated to TTCN-3 as a plain unsignedlong (defined in Annex D.2.1.2 of
ETSI ES 201 873-1 [1]) in XSDAUX XSD:
type unsignedlong unsignedInt UnsignedInt
extension variant "XSD:unsignedInt"
};
6.3.10
with {
short
The short type is 16bit based and translated to TTCN-3 as a plain short (defined in Annex D.2.1.1 of ETSI ES 201 8731 [1]) in XSDAUX XSD:
type short short_ Short with {
extension variant "XSD:short"
};
As “short” is already a keyword, an underscore has to be appended to the name.
6.3.11
unsignedShort
The unsignedShort type is 16bit based and translated to TTCN-3 as a plain unsignedshort (defined in Annex D.2.1.1 of
ETSI ES 201 873-1 [1]) in XSDAUX XSD:
type unsignedshort unsignedShort UnsignedShort
extension variant "XSD:unsignedShort"
};
6.3.12
with {
byte
The byte type is 8bit based and translated to TTCN-3 as a plain byte(defined in Annex D.2.1.0 of ETSI ES 201 873-1
[1]) in XSDAUX XSD:
type byte byte_ Byte with {
extension variant "XSD:byte"
};
ETSI
27
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
As “byte” is already a keyword, an underscore has to be appended to the name.
6.3.13
unsignedByte
The unsignedByte type is 8bit based and translated to TTCN-3 as a plain unsignedbyte (defined in Annex D.2.1.0 of
ETSI ES 201 873-1 [1]) in XSDAUX XSD:
type unsignedbyte unsignedByte UnsignedByte
extension variant "XSD:unsignedByte"
};
6.4
with {
Float types
XSD float types are generally converted to TTCN-3 as subtypes of float. For an overview of the allowed facets please
refer to Table 2 in clause 6.1. Following are details on the mapping of all float types of XSD.
6.4.1
decimal
The decimal type is translated to TTCN-3 as a plain float in XSDAUX XSD:
type float decimal Decimal with {
extension variant "XSD:decimal"
};
6.4.2
float
The float type is translated to TTCN-3 as an IEEE754float (defined in Annex D.2.1.4 of ETSI ES 201 873-1 [1]) in
XSDAUX XSD:
type IEEE754float float_ Float with {
extension variant "XSD:float"
};
As “float” is already a keyword, an underscore has to be appended to the name.
6.4.3
double
The double type is translated to TTCN-3 as an IEEE754double (defined in Annex D.2.1.4 of ETSI ES 201 873-1 [1]) in
XSDAUX XSD:
type IEEE754double double Double with {
extension variant "XSD:double"
};
6.5
Time types
XSD time types are generally converted to TTCN-3 as pattern restricted subtypes of charstring. For an overview of the
allowed facets please refer to Table 2 in clause 6.1. Following are details on the mapping of all time types of XSD.
6.5.1
duration
The duration type is translated to TTCN-3 using the following pattern-restricted charstring in XSDAUX XSD:
type charstring duration Duration (pattern "-?P([\d]+Y)#(0,)([\d]+M)#(0,1)([\d]+D)#(0,1)
(T([\d]+H)#(0,1)([\d]+M)#(0,1)([\d]+(.[\d]+)#(0,1)S)#(0,1))#(0,1)") with {
extension variant "XSD:duration"
};
6.5.2
dateTime
The dateTime type is translated to TTCN-3 using the following pattern-restricted charstring in XSDAUX XSD
type charstring dateTime DateTime (pattern "-?[\d]#(4)-((0[1-9])|[10-12])-((0[1-9])|[1031])T((0[1-9])|[10-23]):((0[1-9])|[10-59]):((0[1-9])|[10-59])(.[\d]+)#(0,1)([+]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:dateTime"
ETSI
28
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
};
6.5.3
time
The time type is translated to TTCN-3 using the following pattern-restricted charstring in XSDAUX XSD:
type charstring time Time (pattern "((0[1-9])|[10-23]):((0[1-9])|[10-59]):((0[1-9])|[1059])(.[\d]+)#(0,1)([+-]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:time"
};
6.5.4
date
The date type is translated to TTCN-3 using the following pattern-restricted charstring in XSDAUX XSD:
type charstring date Date (pattern "-?[\d]#(4)-((0[1-9])|[10-12])-((0[1-9])|[10-31])([+]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:date"
};
6.5.5
gYearMonth
The gYearMonth type is translated to TTCN-3 using the following pattern-restricted charstring in XSDAUX XSD:
type charstring gYearMonth GYearMonth(pattern "[\d]#(4)-((0[1-9])|[10-12])([+]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:gYearMonth"
};
6.5.6
gYear
The gYear type is translated to TTCN-3 using the following pattern-restricted charstring in XSDAUX XSD:
type charstring gYear GYear (pattern "-?\d#(4)([+-]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:gYear"
};
6.5.7
gMonthDay
The gMonthDay type is translated to TTCN-3 using the following pattern-restricted charstring in XSDAUX XSD:
type charstring gMonthDay GMonthDay (pattern "--((0[1-9])|[10-12])-((0[1-9])|[10-31])([+]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:gMonthDay"
};
6.5.8
gDay
The gDay type is translated to TTCN-3 using the following pattern-restricted charstring in XSDAUX XSD:
type charstring gDay GDay (pattern "---((0[1-9])|[10-31])([+-]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:gDay"
};
6.5.9
gMonth
The gMonth type is translated to TTCN-3 using the following pattern-restricted charstring in XSDAUX XSD:
type charstring gMonth GMonth (pattern "--((0[1-9])|[10-12])([+-]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:gMonth"
};
ETSI
29
6.6
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Sequence types
XSD sequence types are generally converted to TTCN-3 as a set record of their respective base types. For an overview
of the allowed facets please refer to Table 2 in clause 6.1. Following are details on the mapping of all sequence types of
XSD.
6.6.1
NMTOKENS
The NMTOKENS type is mapped to TTCN-3 using a set record of construct of type NMTOKEN in XSDAUX XSD:
type set record of NMTOKEN NMTOKENS with {
extension variant "XSD:NMTOKENS"
};
6.6.2
IDREFS
The IDREFS type is mapped to TTCN-3 using a set record of construct of type IDREF in XSDAUX XSD:
type set record of IDREF IDREFS with {
extension variant "XSD:IDREFS"
};
6.6.3
ENTITIES
The ENTITIES type is mapped to TTCN-3 using a set record construct of type ENTITY in XSDAUX XSD:
type set record of ENTITY ENTITIES with {
extension variant "XSD:ENTITIES"
};
6.6.4
QName
The QName type is translated to TTCN-3 as a plain charstring below in XSDAUX XSD:
type charstring QName with {
extension "XSD:QName"
};
type record QName
{
AnyURI uri
optional,
NCName name
}with {
variant "XSD:QName"
};
When encoding an element of type QName (or derived from QName), if the encoder detects the presence of an URI
and this is different from the target namespace , the folowing encoding results (the assumed target namespace is
http://www.organization.org/):
type record E14a
{
QName
name ,
integer refId
}
template E14a
t_E14a:=
{
name:={
uri:=”http://www.otherorganization.org/”,
name:=”someName”
},
refId:=10
}
ETSI
30
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
<?xml version=”1.0” encoding=”UTF-8”?>
<E14a xmlns=”http://www.organization.org/”>
<name xmlns:ns=”http://www.otherorganization.org/”>ns:someName</name>
<refId>10</refId>
</E14a>
It is not legal to specify length restrictions for QName types.
6.7
Boolean type
The boolean type is mapped to TTCN-3 using as a boolean in XSDAUX XSD:
type boolean boolean_ Boolean with {
extension variant "XSD:boolean"
};
As “boolean” is already a keyword, an underscore has to be appended to the name. During translation of XSD boolean
values it is necessary to handle all four values that XSD allows for booleans (“true”, “false”, “0”, and “1”); “true”
and “1” have to be mapped to true, whereas “false” and “0” have to be mapped to false. This will be realized using the
“text” encoding instruction:
type Boolean MyBooleanType with {
variant "text ‘true’ as ‘1’";
variant "text ‘false’ as ‘0’";
};
6.8
anyType, anySimpleType types
anySimpleType can be considered as the base type of all primitive datatypes, while anyType is the base type of all
complex definitions and the anySimpleType.
anySimpleType is translated as an XML compatible restricted subtype of the universal charstring in XSD:
type XMLCompatibleString AnySimpleType with {
variant "XSD:anySimpleType"
};
while anyType is translated into XML content opaque to the codec:
type record AnyType
{
record of String attr,
record of String elem_list
} with {
variant "XSD:anyType";
variant "anyAttributes ‘attr’";
variant "anyElement ‘elem_list’”;
};
Without support for mixed content. See also ch.7.7 (anyAttributes, anyElement).
ETSI
31
7
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Mapping XSD components
After mapping the basic layer of XML Schema (i.e. the built-in types) a mapping of the structures has to follow. Every
structure that may appear, globally or not, needs to have a corresponding mapping to TTCN-3.
The guiding principle of mapping is alignment to ITU-T Rec.X.694: all structures are the result of two subsequent
transformations applied to the XSD Schema: first , transformations descibed in ITU-T Rec.X.694 , then transformations
described in ETSI standard ES 201 873-7.
7.1
Attributes of XSD component declarations
Table 5 and Table 6 contain an overview about the major attributes that are encountered during mapping. It is not
complete: special attributes that are only used by a single XSD component are described in the corresponding
subclauses. Table 5 and Table 6 show which attributes are needed to be evaluated when converting to TTCN-3,
depending on the XSD component to be translated.
Table 5: Attributes of XSD component declaration #1
element
attribute
simple
type
complex
type
simple
content
complex
content
group
id







final



name



maxOccurs


minOccurs


ref

abstract


block


default


fixed


form


type


component
attribute





mixed

Table 6: Attributes of XSD component declaration #2
component
all
choice
sequence
attribute
Group
annotation
restriction
list
union








attribute
id

name
maxOccurs



minOccurs



ref

ETSI
extension

32
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
It is also necessary to consider default values for attributes coming from the original definitons of the XSD components
(e.g. minOccurs is set to 1 for element components by default) when translating.
7.1.1
id
The attribute id enables a unique identification of an XSD component. They are mapped to TTCN-3 as simple type
references, e.g. any component mapping to a type with name typeName and an attribute id="ID" should result in an
additional TTCN-3 type declaration:
type typeName Typename ID;
7.1.2
ref
The ref attribute may reference an id or any global type (see clause 7.2).
If the attribute is referring to an id it’s directly mapped as a simple type, e.g. a component with an attribute ref="MyREF"
is translated to:
type MyREF typeName Typename;
In the case that REF references a global type the name of the global type has to be substituted, e.g.
type globalType GlobalType typeName Typename;
7.1.3
name
The attribute name holds the specified name for an XSD component. A component without this attribute is either
defined anonymously or given by a reference (see clause 7.1.2). Names are directly mapped to TTCN-3 identifiers;
please refer to clause 5.2 on constraints and properties of this conversion.
7.1.4
minOccurs and maxOccurs
The minOccurs and maxOccurs attributes provide for the number of times a XSD component can appear in a context. It
is translated to a length restricted set record of in TTCN-3. For example a XSD component with minOccurs and
maxOccurs attributes would be translated as:
<complexType name="e15">
<sequence minOccurs="5" maxOccurs="10">
<element name="foo" type="integer"/>
<element name="bar" type="float"/>
</sequence>
</complexType>
Is translated to a record (for the inner sequence, see clause 7.6.6) and a length-restricted set record of record:
type record ANONYM1__sequence {
XSDAUX.integer_ foo,
XSDAUX.float_ bar
}
type set length(5 .. 10) of ANONYM1__sequence e8__complexType;
type record E15
{
record length(5 .. 10) of record
{
XSD.Integer foo,
XSD.Float
bar
} sequence_list
}
with
{
variant "name ‘E15’ as uncapitalized ";
};
If only one boundary is given, the other boundary is established by the type or default value of the XSD structure. If a
boundary value is unbounded the TTCN-3 keyword infinity has to be used. Also if minOccurs has a value of 0 a
ETSI
33
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
translator has to make sure that the resulting type is set to optional, if in this case maxOccurs has a value of 1 the whole
set of generation has to be skipped. Also if minOccurs has a value of 0 , and maxOccurs has a value of 1, or is not
present (defaulting to 1), a translator has to make sure that the resulting field ‘sequence’ is optional:
<complexType name="e15a">
<sequence minOccurs="0">
<element name="foo" type="integer"/>
<element name="bar" type="float"/>
</sequence>
</complexType>
results in:
type record E15a
{
record
{
XSD.Integer foo,
XSD.Float
bar
} sequence optional
}
with
{
variant "name ‘E15a’ as uncapitalized ";
};
7.1.5
default and fixed
The default attribute assigns a default value to a component in cases where it is missing in the XML data.
The fixed attribute gives a fixed constant value to a component according to the given type, so in some XML data the
value of the component may be omitted.
The mapping of these special values should generate a special template alongside the translated type itself. As ‘default’
and ‘fixed’ have no equivalent in TTCN-3 space, they will be mapped into codec instructions. For example:
<element name=”elementDefault” type=”string” default=”defaultValue”/>
<element name=”elementFixed” type=”string” fixed=”fixedValue”/>
will be translated as:
The special value is put into a template of the previous type:
template elementDefault := “defaultValue”;
template elementFixed := “fixedValue”;
type XSD.String ElementDefault
with {
variant “element”;
variant “defaultForEmpty as ‘defaultValue’ ”;
variant “name ‘ElementDefault’ as uncapitalized “;
};
type XSD.String ElementFixed (“fixedValue”)
with {
variant “element”;
variant “defaultForEmpty as ‘fixedValue’” ;
variant “name ‘ElementFixed’ as uncapitalized “;
};
ETSI
34
7.1.6
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
form
Mapping of the form attribute is not supported by the standard.
7.1.7
type
The type attribute holds the type information of the XSD component. The value is a reference to the global definition of
simpleType, complexType or built-in type. If type is not given the component must define either an anonymous (inner)
type, or contain a reference attribute (see clause 7.1.2), or use the XSD ur-type definition.
7.1.8
mixed
Mixed content is not supported. All content has to be described by a schema.
7.1.9
abstract
Mapping of the abstract attribute is not supported by the standard.
7.1.10
block and final
Mapping of the block and final attributes are not supported by the standard.
7.2
schema component
This is the root component of a XSD declaration. It is translated to the general structure of a TTCN-3 module
containing all mapped types of the XSD schema. All direct children of schema are treated global and therefore need to
be identifiable by id or name.
7.3
element component
A XSD element component defines a new XML element. Elements may be global (as a child of either schema or
redefine), in which case they are obliged to contain a name attribute or may be defined locally (as a child of all, choice
or sequence) using a name or ref attribute.
An example of a globally defined element:
<element name=”e16” type=”typename”/>
is translated to:
type typename e16;
type typename E16
with {
variant “element”;
variant “name ‘E16’ as uncapitalized “;
};
Locally defined elements will be mapped to fields, refer to clause 7.6 about examples on this kind of mapping.
Among the possible attributes an element may posses are the special attributes nillable and substitutionGroup.
The nillable attribute, when set to true, gives the possibility of an element having the special value "xsi:nill" value in
any XML data. This value loosely correspondences to null in TTCN-3. As the usage of null cannot be suppressed in
TTCN-3, the nillable attribute is ignored. This will be implemented using an appropriate encoding extension:
<complexType name="e16a">
<sequence>
<element name="foo" type="integer"/>
<element name="bar" type="string" nillable=”true”/>
</sequence>
</complexType>
Is translated into:
ETSI
35
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
type record E16a
{
XSD.Integer foo,
record {
XSD.String content optional
}
bar
}
with
{
variant "useNil ‘bar’";
variant "name ‘E16a’ as uncapitalized ";
};
Which allows e.g. the following encoding:
template t_E16a:=
{
foo:=3,
bar:= {
content:=omit
}
}
<?xml version=”1.0” encoding=”UTF-8”?>
<e16a>
<foo>3<foo/>
<bar xsi:nil=”true”/>
</e16a>
Mapping of the substitutionGroup attribute is not supported by the standard.
For conversion of other attributes refer to clause 7.1.
7.4
attribute components
Attributes define valid attributes for XML data and are used when defining complex types. Just like elements attributes
can be defined globally (as a child of schema or redefine) and then be referenced from other definitions or defined
locally (as a child of complexType, restriction, extension or attributeGroup) without the possibility of being used
outside of their context. Attributes are basically mapped in the same way as elements (see clause 7.3) , and an
appended with- clause marking them as attributes. For example, a globally defined attribute:
<attribute name="e17" type="typename"/>
is mapped to:
type typename e8__attribute with {
extension "Attribute"
};
type typename E17 with {
variant "attribute";
variant “name ‘E17’ as uncapitalized “;
};
Locally defined attributes will be mapped to a TTCN-3 set record containing a reference to the type definition they are
belonging to and using either a generated name (if defined anonymously) or their assigned name. The generated
structures are also appended with a with-clause marking the fields in question as attributes. Take for an example a
generated with-clause for a type with two attributes foo and bar:
<complexType name="e17a">
<attribute name="foo" type="integer"/>
<attribute name="bar" type="float"/>
</complexType>
ETSI
36
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
type record E17a
{
XSD.Float
bar optional,
XSD.Integer foo optional
}
with
{
variant "attribute ‘foo’, ‘bar’";
variant "name ‘E17a’ as uncapitalized ";
};
type set … {
… definition of fields foo and bar …
} with {
extension "Attribute: foo, bar"
};
While:
<attribute name="foo" type="string"/>
<complexType name="e17b">
<sequence>
<element name="e" type="string"/>
</sequence>
<attribute ref="foo"/>
<attribute name="bar" type="string"/>
</complexType>
type XSD.String Foo with {
variant "attribute";
variant “name ‘Foo’ as uncapitalized “;
}
type record E17b
{
Foo
foo,
XSD.String bar,
XSD.String e
}
with
{
variant
variant
}
"attribute ‘foo’, ‘bar’";
"name ‘E17b’ as uncapitalized ";
Refer to the appropriate subsections of clause 7.6 for examples on this kind of mapping.
Besides the general attributes (as laid out in clause 7.1) attribute declarations may contain the special attribute use. The
use attribute specifies whether an attribute (declared inside a structured type) is mandatory or not. The values of this
attribute are: optional, prohibited and required. The value required does not to be translated as the existence of values is
mandatory in TTCN-3. The value prohibited is used only in case of restricting complexTypes (see clause 7.6.1.1 or
7.6.2.2 on restricting content of complex types). The value optional is translated by using the TTCN-3 keyword
optional with the appropriate fields.
7.5
simpleType components
Simple types may be defined globally (as child of schema and using a mandatory name attribute) or locally (as a child of
element, attribute, restriction, list or union) in a named or anonymous fashion. The simpleType components are
used to define new simple types by three means:

Restricting a built-in type (with the exception of anyType, anySimpleType) by applying a facet
to it

Building lists

Building unions of other simple types.
ETSI
37
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
These means are quite different in their translation to TTCN-3 and are explained in the following clauses. For the
translation of attributes for simple types please refer to the general mappings defined in clause 7.1. Please note that a
simpleType is not allowed to contain elements or attributes, redefinition of these is done by using complexType (see
clause 7.6).
7.5.1
Derivation by restriction
For information about restricting built-in types, please refer to chapter 6 which contains an extensive description on the
translation of restricted simpleType using facets to TTCN-3.
It is also possible to restrict an anonymous simple type. The translation follows the mapping for built-in datatypes, but
instead of using the base attribute to identify the type to apply the facet to, the base attribute type is omitted and the type
of the inner, anonymous simpleType is used. Consider the following example restricting an anonymous simpleType
using a pattern facet (the bold part marks the inner simpleType):
<simpleType name="e18">
<restriction>
<simpleType>
<restriction base="string"/>
</simpleType>
<pattern value="(ahi|eho|cre|dve)@(f|F)okus"/>
</restriction>
</simpleType>
This will generate a mapping for the inner type and a restriction thereof:
type XSDAUX.string e18__simpleType (pattern "((ahi|eho|cre|dve)@(f|F)okus)#(1)");
type XSD.String E18 (pattern "((ahi|eho|cre|dve)@(f|F)okus)#(1)")
with {
variant “name ‘E18’ as uncapitalized “;
};
7.5.2
Derivation by list
XSD list components are mapped to the TTCN-3 set record of type. In their simplest form lists are mapped by directly
using the listItem attribute as the resulting type, e.g.
<simpleType name="e19">
<list itemType="float"/>
</simpleType>
Will translate to
type set of XSDAUX.float_ e19;
type record of XSD.Float E19
with {
variant “list”;
variant “name ‘E19’ as uncapitalized“;
};
When using any of the supported facets (length, maxLength, minLength) the translation is more complex and follows
the mapping for built-in list types, with the difference that the base type is determined by an anonymous inner list item
type (This is similar to clause 7.5.1). Consider this example:
<simpleType name="e20">
<restriction>
<simpleType>
<list itemType="float"/>
</simpleType>
<length value="3"/>
</restriction>
</simpleType>
Will map to:
type set length(3) of XSDAUX.float_ e20__simpleType;
type record length(3) of XSD.Float E20
with {
variant “list”;
variant “name ‘E20’ as uncapitalized“;
};
ETSI
38
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
For instance
template
E20 t_E20 :={1.0,2.0,3.0}
will be encoded as:
<?xml version=”1.0” encoding=”UTF-8”?>
<e20>
1.0 2.0 3.0
</e20>
The other facets are mapped accordingly (refer to respective 6.1 clauses). If no itemType is given, the
mapping has to be implemented using the given inner type (for an example refer to clause 7.5.3)
7.5.3
Derivation by union
A union is considered as a set of mutually exclusive alternatives types for a simpleType. As this is compatible with the
union concept of TTCN-3 a simpleType union in XSD is mapped to a union structure in TTCN-3. e.g.
<simpleType name="e21">
<union>
<simpleType>
<restriction base="string"/>
</simpleType>
<simpleType>
<restriction base="float"/>
</simpleType>
</union>
</simpleType>
Results in the following mapping:
type union e8__union {
XSDAUX.string union_1,
XSDAUX.float_ union_2
}
type union E821
{
XSD.String alt_0,
XSD.Float alt_1
} with {
variant “name ‘alt_0’ as ‘’”;
variant “name ‘alt_1’ as ‘’”;
variant “useUnion”
variant “name ‘E21’ as uncapitalized“;
};
For instance , the below structure
type record E21 e21a
{
E21 e21,
XSD.String foo
}
template t_E821a:={
e21 :={
alt_0 :=”ding”
},
foo:=”foostring”
}
will result in the following encoding:
ETSI
39
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
<?xml version=”1.0” encoding=”UTF-8”?>
<e21a xmlns:xsi=’http://www.w3.org/2001/XMLSchema-instance’>
<e21 xsi:type=”string”>ding</e21>
<foo>foostring</foo>
</e21a>
Using the attribute memberTypes, a union allows for a direct specification of member types as a whitespace separated
list of type identifiers. The mapping to TTCN-3 is done in the same way as for the attribute listItem of the list derivation
component (see clause 7.5.2).
As union fields in TTCN-3 are more limited than pure type definitions it is necessary to introduce additional types when
converting more complex types (e.g. a simpleType of a length-restricted list as given as example in clause 7.5.2). To do
these conversions, the introduction of an additional intermediate anonymous type is inevitable.
The only supported facet is enumeration, allowing mixing enumerations of different kinds. Consider this example:
<simpleType name="e22”>
<restriction base="e21">
<enumeration value="20"/>
<enumeration value="50"/>
<enumeration value="small"/>
</restriction>
</simpleType>
Translates to:
type e21__union e22__simpleType(20, 50, "small");
type E21 E22 ({alt_1:=20.0},{alt_1:=50.0},{alt_0:="small"})
with {
variant “name ‘E22’ as uncapitalized“;
};
7.6
complexType components
The complexType is used for creating new types that contain other elements and attributes. Just like simpleType,
complexType may be defined globally (as child of schema or redefine). In this case the name attribute is mandatory and
the resulting TTCN-3 type will be mapped to the value of this attribute. A complexType may also be defined locally (as
a child of element) in an anonymous fashion (without the name attribute), therefore prohibiting to be referenced from
other type definitions.
The mapping of a complexType is done by translating every child that this complexType may have and subsequently
combining them by using a TTCN-3 set record type or direct reference. A set record type has to be used when the
complexType contains attributes and a direct reference is used when no additional attributes are declared. The content of
a complexType consists of either a simpleContent or complexContent component or a valid combination of group, all,
choice, sequence, attribute, attributeGroup or anyAttribute components (see clause 3.4.2 in document [5]). Following is
a description of the mapping for the different possible content components.
7.6.1
complexType containing simpleContent
A simpleContent component is translated to types that may only have a simpleType as base. It is possible to extend or
restrict the base type and to add attributes, but not elements.
7.6.1.1
Extending simpleContent
When extending simpleContent further attributes may be added to the original type. The example below extends a builtin type by adding an attribute. The mapping result of an extended simpleContent type with added attributes is always a
set record containing the base type as a field referenced by the reserved name base.
<complexType name="e23">
<simpleContent>
<extension base="string">
<attribute name="foo" type="float"/>
</extension>
</simpleContent>
</complexType>
ETSI
40
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Will be mapped as:
type set e23_complexType {
XSDAUX.string base,
XSDAUX.float_ foo optional
} with {
extension "Attribute: foo"
};
type record E23
{
XSD.Float foo optional,
XSD.String base
} with {
variant “untagged ‘base’“;
variant "attribute ‘foo’";
variant “name ‘E23’ as uncapitalized“;
};
7.6.1.2
Restricting simpleContent
To restrict simpleContent additional, more restrictive, facets are applied to the base type or to attributes of the base type.
The whole type needs to be redefined in the restricted version, translating to a completely new type definition in
TTCN-3. Consider the following example for restriction of a base type:
<complexType name="e24">
<simpleContent>
<restriction base="e23">
<length value="4"/>
</restriction>
</simpleContent>
</complexType>
Is translated to:
type XSDAUX.string e24__complexType length(4);
type record E24
{
XSD.Float foo optional,
XSD.String base length(4)
} with {
variant “untagged ‘base’“;
variant "attribute ‘foo’";
variant “name ‘E24’ as uncapitalized“;
};
As the restricted complex type would translate to a set with only one field, the field is directly used as type. Other base
types are dealt with accordingly, see clause 6.
7.6.2
complexType containing complexContent
In contrast to simpleContent, complexContent is allowed to have elements. It is possible to extend a base type by adding
attributes or elements, it is also possible to restrict a base type to certain elements or attributes.
7.6.2.1
Extending complexContent
By using extension for a complexContent it is possible to add attributes, elements or groups of those (group,
attributeGroup) to the complex base type. This is translated to TTCN-3 by creating a record containing a reference to
the base type using the reserved word “base” the referenced structure and the extension components.
For an example consider the following complexType:
<complexType name="e259">
<sequence>
<element name="title" type="string"/>
<element name="forename" type="string"/>
ETSI
41
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
<element name="surname" type="string"/>
</sequence>
</complexType>
The resulting mapping (according to clause 7.6.6) of the above complexType is:
type record e25__complexType {
XSDAUX.string title,
XSDAUX.string forename,
XSDAUX.string surname
}
type record
{
XSD.String
XSD.String
XSD.String
}
with
{
variant
};
E25
title,
forename,
surname
"name ‘E25’ as uncapitalized ";
Now a type is defined that extends foo by adding a new element
<complexType name="e26">
<complexContent>
<extension base="e25">
<sequence>
<element name="age" type="integer"/>
</sequence>
</extension>
</complexContent>
</complexType>
This translates to the TTCN-3 structure
type record e26__complexType {
e25__complexType base,
XSDAUX.integer_ age
}
type record
{
XSD.String
XSD.String
XSD.String
XSD.Integer
}
with
{
variant
};
E26
title,
forename,
surname,
age
"name ‘E26’ as uncapitalized ";
As the base content and extension content are of the same structure (sequence), the extension content is directly mapped
to the result structure (e26__complexType). In the case of different structures an anonymous type a nested structure
would be generated and referenced as content. Consider an extension with a different structure:
<complexType name="e27">
<complexContent>
<extension base="e25">
<choice>
<element name="age" type="integer"/>
<element name="birthday" type="date"/>
</choice>
</extension>
</complexContent>
</complexType>
This translates to the following TTCN-3 structures:
ETSI
42
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
type union ANONYM2__choice {
XSDAUX.integer_ age,
XSDAUX.date_ birthday
}
type record e27__complexType {
e9__complexType base,
ANONYM2__choice content
}
type record E27
{
XSD.String title,
XSD.String forename,
XSD.String surname,
union {
XSD.Integer age ,
XSD.Date
birthday
} choice
}
with
{
variant "name ‘E27’ as uncapitalized ";
variant “untagged ‘choice’”;
};
7.6.2.2
Restricting complexContent
The restriction uses a base type and restricts some of its components. This is mapped to a new type containing only the
components of the restriction. In the example below anyType (any possible type) is used as the base type and it is
restricted to only two elements. As the resulting type is a sequence without additional attributes a TTCN-3 record is
used (see clause 7.6.6 on mapping of sequences), otherwise a set would be constructed containing base type and
attributes. Take for an example:
<complexType name="e28">
<complexContent>
<restriction base="anyType">
<sequence>
<element name="size" type="nonPositiveInteger"/>
<element name="unit" type="NMTOKEN"/>
</sequence>
</restriction>
</complexContent>
</complexType>
Is translated to:
type record e28__complexType {
XSDAUX.nonPositiveInteger size,
XSDAUX.NMTOKEN unit
}
type record E28
{
XSD.NonPositiveInteger size,
XSD.NMTOKEN
unit
}
with
{
variant "name ‘E28’ as uncapitalized ";
};
7.6.3
group components
A group component defines an atomic group of elements for inclusion in other definitions. Groups can be local
(anonymous) or global (with a mandatory name or id) and may consist of a single choice, sequence or all component.
This translates to a single TTCN-3 type definition which is identified by the name (resp. id) of the group. Refer to the
appropriate parts of clause 7.6 for more detailed information on the mapping of choice, sequence or all structures.
ETSI
43
7.6.4
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
all content
An all content structure defines an unordered collection of optional elements. This is translated in
TTCN-3 as a set containing only optional fields, e.g. a record with elements mapped to optional fields
and a first field named ‘order’ reflecting the order and presence of fields within the record:
<complexType name="e29">
<all>
<element name="foo" type="integer"/>
<element name="bar" type="float"/>
<element name="ding" type="string"/>
</all>
</complexType>
Is mapped to the following TTCN-3 structure:
type set e299__comnplexType {
XSDAUX.integer_ foo optional,
XSDAUX.float_ bar optional,
XSDAUX.string ding optional
}
type record E29
{
record of enumerated {foo,bar,ding} order,
XSD.Integer foo optional,
XSD.Float
bar optional,
XSD.String ding optional
}
with
{
variant "name ‘E29’ as uncapitalized ";
variant "useOrder";
};
NOTE: When encoding, the presence and order of elements in the encoded XML instance will be controlled by the
‘order’ field. When decoding, the presence and order of elements in the XML instance will control the value of the
‘order’ field that appears in the decoded structure.
7.6.5
choice content
A choice content defines a collection of mutually exclusive alternatives for a type. It is thus mapped to the union type in
TTCN-3, as it allows only one of the components to appear in the instance. The content for a choice component may be
any combination of element, group, choice, sequence or any.
The following subsections give examples of the mapping for various contents nested in a choice component.
7.6.5.1
choice with nested element
Nested elements are directly mapped to a union containing the choice’s content, e.g.
<complexType name="e30">
<choice>
<element name="foo" type="integer"/>
<element name="bar" type="float"/>
</choice>
</complexType>
Will be translated as
type union e30__complexType {
XSDAUX.integer_ foo,
XSDAUX.float_ bar
}
ETSI
44
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
type record E30
{
union {
XSD.Integer foo,
XSD.Float
bar
} choice
}
with
{
variant
variant
};
7.6.5.2
"name ‘E30’ as uncapitalized ";
"untagged ‘choice’";
choice with nested group
Nested group components will be mapped along other content as a field in the union . The following example shows
this with a sequence group and an element:
<group name="e31">
<sequence>
<element name="foo" type="string"/>
<element name="bar" type="string"/>
</sequence>
</group>
<complexType name="e32">
<choice>
<group ref="e31"/>
<element name="ding" type="string"/>
</choice>
</complexType>
The group is mapped to a record (it is a sequence, see clause 7.6.6) and then the choice is translated to a union:
type record e31__group {
XSDAUX.string foo,
XSDAUX.string bar
}
type union e32_complexType {
e9__group choice_1,
XSDAUX.string ding
}
type record E31
{
XSD.String foo,
XSD.String bar
}
with
{
variant "name E31 as uncapitalized ";
};
type record E32
{
union {
E31
e31,
XSD.String ding
} choice
}
with
{
variant "name ‘E32’ as uncapitalized ";
variant "untagged ‘choice’";
};
7.6.5.3
choice with nested choice
A choice with a nested choice is translated as nested unions in TTCN-3, e.g.
ETSI
45
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
<complexType name="e33">
<choice>
<choice>
<element name="foo" type="string"/>
<element name="bar" type="string"/>
</choice>
<element name="ding" type="string"/>
</choice>
</complexType>
Will be mapped as
type union ANONYM3__choice {
XSDAUX.string foo,
XSDAUX.string bar
}
type union e33__complexType {
ANONYM3__choice choice_1,
XSDAUX.string ding
}
type record E33
{
union
{
union
{
XSD.String foo,
XSD.String bar
} choice,
XSD.String ding
}choice
} with
{
variant
variant
};
7.6.5.4
"name ‘E33’ as uncapitalized ";
"untagged ‘choice’, ‘choice.choice’";
choice with nested sequence
A choice with a nested sequence will be mapped to a union containing a record, e.g.
<complexType name="e34">
<choice>
<sequence>
<element name="foo" type="string"/>
<element name="bar" type="string"/>
</sequence>
<element name="ding" type="string"/>
</choice>
</complexType>
Is translated to:
type record ANONYM4__sequence {
XSDAUX.string foo,
XSDAUX.string bar
}
type union e34__complexType {
ANONYM4__sequence choice_1,
XSDAUX.string ding
}
ETSI
46
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
type record E34
{
union
{
record
{
XSD.String foo,
XSD.String bar
}
sequence,
XSD.String ding
} choice
} with
{
variant
variant
};
7.6.5.5
"name ‘E34’ as uncapitalized ";
"untagged ‘choice’,’choice.sequence’";
choice with nested any
As the TTCN-3 anytype is defined to be a union of all types of the present module and every other
imported module, a A choice containing XSD any types will translate to anytype in TTCN-3, e.g.
<complexType name="e35">
<choice>
<element name="foo" type="string"/>
<any namespace="other"/>
</choice>
</complexType>
Will translate to
type anytype e35__complexType;
type record E35
{
union {
XSD.String foo,
XSD.String elem
} choice
}
with
{
variant "name ‘E35’ as uncapitalized";
variant “anyElement ‘elem’ from “other” “;
variant “untagged ‘choice’”
};
See also ch.7.7 for details.
7.6.6
sequence content
A sequence defines an ordered collection of components and is mapped to a record in TTCN-3. The content of a
sequence may be any combination of element, group, choice, sequence or any.
The following subsections give examples of the mapping for various contents nested in a sequence component.
7.6.6.1
sequence with nested element content
Sequences that contain only elements are mapped as a plain record in TTCN-3, e.g.
<complexType name="e36">
<sequence>
<element name="foo" type="integer"/>
<element name="bar" type="float"/>
</sequence>
</complexType>
ETSI
47
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Is mapped to
type record e36__sequence {
XSDAUX.integer_ foo,
XSDAUX.float_ bar
}
type record
{
XSD.Integer
XSD.Float
}
with
{
variant
};
7.6.6.2
E36
foo,
bar
"name ‘E36’ as uncapitalized";
sequence with nested group content
Nested group components will be mapped along other content as a field in the record. The following example shows
this translation with a choice group and an element:
<group name="e37">
<choice>
<element name="foo" type="string"/>
<element name="bar" type="string"/>
</choice>
</group>
<complexType name="e38">
<sequence>
<group ref="e37"/>
<element name="ding" type="string"/>
</sequence>
</complexType>
The group is mapped to a union (it is a choice, see clause 7.6.5) and then the sequence is translated to a record:
type union e37__group {
XSDAUX.string foo,
XSDAUX.string bar
}
type record e38__complexType {
e9__group sequence_1,
XSDAUX.string ding
}
type union E37
{
XSD.String foo,
XSD.String bar
}
with
{
variant "name ‘E37’ as uncapitalized";
variant “untagged”;
};
type record E38
{
E37
e37,
XSD.String ding
} with
{
variant "name ‘E38’ as uncapitalized";
};
7.6.6.3
sequence with nested choice content
A sequence with a nested choice will be mapped to a record containing a union, e.g.
ETSI
48
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
<complexType name="e39">
<sequence>
<choice>
<element name="foo" type="string"/>
<element name="bar" type="string"/>
</choice>
<element name="ding" type="string"/>
</sequence>
</complexType>
Is translated to
type union ANONYM5__choice {
XSDAUX.string foo,
XSDAUX.string bar
}
type record e39__complexType {
ANONYM5__choice sequence_1,
XSDAUX.string ding
}
type record E39
{
union {
XSD.String foo,
XSD.String bar
}
choice,
XSD.String ding
}
with
{
variant "name ‘E39’ as uncapitalized";
variant “untagged ‘choice’”;
};
7.6.6.4
sequence with nested sequence content
A sequence with a nested sequence is translated as nested records in TTCN-3, e.g.
<complexType name="e40">
<sequence>
<sequence>
<element name="foo" type="string"/>
<element name="bar" type="string"/>
</sequence>
<element name="ding" type="string"/>
</sequence>
</complexType>
Will be mapped as
type record ANONYM6__sequence {
XSDAUX.string foo,
XSDAUX.string bar
}
type record e40__complexType {
ANONYM6__sequence sequence_1,
XSDAUX.string ding
}
type record E40
{
XSD.String foo,
XSD.String bar,
XSD.String ding
} with
{
variant "name ‘E40’ as uncapitalized";
};
ETSI
49
7.6.6.5
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
sequence with nested any content
A sequence with nested any maps to a TTCN-3 record containing an anytype (see clause 7.6.5.5), e.g.
<complexType name="e41">
<sequence>
<element name="foo" type="string"/>
<any/>
</sequence>
</complexType>
Will translate to
type record e41__complexType {
XSDAUX.string foo,
anytype sequence_1
}
type record E41
{
XSD.String foo,
XSD.String elem
}
with
{
variant "name ‘E41’ as uncapitalized";
variant “anyElement ‘elem’ “;
};
See also ch.7.7 for details.
7.6.7
attributeGroup components
An attributeGroup defines a group of attributes that can be included together inside other definitions. Attribute groups
map to a set in TTCN-3 with all optional fields and a mandatory with-extension marking them as an attributeGroup.
They are globally defined (as direct child of schema or redefine and requiring a name attribute) and locally referenced
(requiring a ref attribute). If an attributeGroup is referenced within another attributeGroup all attributes referenced need
to be merged in a single set. Consider the following example:
<attributeGroup name="e42">
<attribute name="foo" type="float"/>
<attribute name="bar" type="float"/>
</attributeGroup>
<attributeGroup name="e43">
<attributeGroup ref="e42"/>
<attribute name="ding" type="string"/>
</attributeGroup>
Translates to TTCN-3 as
type set e42__attributeGroup {
XSDAUX.float_ foo optional,
XSDAUX.float_ bar optional
} with {
extension "AttributeGroup"
};
type set e43__attributeGroup {
XSDAUX.float_ foo optional,
XSDAUX.float_ bar optional,
XSDAUX.string ding optional
} with {
extension "AttributeGroup"
};
ETSI
50
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
type set E42
{
XSD.Float foo optional,
XSD.Float bar optional
} with {
variant "name ‘E42’ as uncapitalized";
variant "attributeGroup";
};
type set E43
{
XSD.Float foo optional,
XSD.Float bar optional,
XSD.String ding optional
} with {
variant "name ‘E43’ as uncapitalized";
variant "attributeGroup"
};
If attributeGroup components are referenced from a complexType, restriction or extension, a reference to the
attributeGroup is generated and resolved by insertion inserted in the mapped construct, e.g.
<complexType name="e44">
<sequence>
<element name="ding" type="string"/>
</sequence>
<attributeGroup ref="e42"/>
</complexType>
type set e9__complexType {
XSDAUX.string ding,
e9__attributeGroup attributeGroup_1
}
type record E44
{
XSD.String ding,
XSD.Float foo optional,
XSD.Float bar optional
} with {
variant "name ‘E44’ as uncapitalized";
variant "attribute ‘foo’,’bar’"
};
7.7
any, anyAttribute
An any element specifies that any well-formed XML is permissible in a type's content model. The content of this XML
will not be parsed and interpreted by the encoder and decoder. In addition to the any element which enables element
content according to namespaces, there is a corresponding anyAttribute element which enables transparent (from the
codec’s point of view) attributes to appear in elements.
The codec will be controlled by an ‘anyAttribute’ and ‘anyElement’ instruction, complemented with ‘from’ and
‘except’ clauses specifying the comma-separated list of namespaces which are allowed or restricted to qualify the given
attribute or element. An ‘unqualified’ clause in the list of allowed namespaces allows unqualified attributes or elements,
respectively, while an ‘unqualified’ clause in the list of restricted namespaces forbids such attributes or elements.
For the following examples, the target namespace is assumed to be the following URI:
http://www.organization.org/ttcn/wildcard.
The below complexType definitions:
<xs:complexType name="e45">
<xs:anyAttribute namespace="##any"/>
</xs:complexType>
<xs:complexType name="e45a">
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
ETSI
51
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
<xs:complexType name="e45b">
<xs:anyAttribute namespace="##targetNamespace"/>
</xs:complexType>
<xs:complexType name="e45c">
<xs:anyAttribute namespace="##local http://www.organization.org/ttcn/attribute"/>
</xs:complexType>
<xs:complexType name="e45d">
<xs:complexContent>
<xs:extension base="e45c">
<xs:anyAttribute namespace="##targetNamespace"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
will be mapped as follows:
type record E45
{
record of XSD.String
attr
} with
{
variant "name ‘E45’ as uncapitalized";
variant “anyAttributes ‘attr’”;
};
type record E45a
{
record of XSD.String
attr
} with
{
variant "name E45a as uncapitalized";
variant “anyAttributes ‘attr’ except ‘http://www.organization.org/ttcn/wildcard’”;
};
type record E45b
{
record of XSD.String
attr
} with
{
variant "name ‘E45b’ as uncapitalized";
variant “anyAttributes ‘attr from ‘http://www.organization.org/ttcn/wildcard’”;
};
type record E45c
{
record of XSD.String
attr
} with
{
variant "name ‘E45c’ as uncapitalized";
variant “anyAttributes ‘attr’ from
unqualified,’http://www.organization.org/ttcn/attribute’”;
};
type record E45d
{
record of XSD.String
attr
} with
{
variant "name ‘E45d’ as uncapitalized";
variant “anyAttributes ‘attr’ from
unqualified,’http://www.organization.org/ttcn/attribute’,’http://www.organization.org/ttcn/wil
dcard’”;
};
The below examples of a content model wildcard:
ETSI
52
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
<xs:complexType name="e46">
<xs:sequence>
<xs:any namespace="##any"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="e46b">
<xs:sequence>
<xs:any minOccurs="0" namespace="##other"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="e46c">
<xs:sequence>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##local"/>
</xs:sequence>
</xs:complexType>
Are mapped to the following TTCN-3 code and encoding extensions:
type record E46
{
XSD.String
elem
} with
{
variant "name ‘E46’ as uncapitalized";
variant “anyElement ‘elem’”;
};
type record E46a
{
XSD.String
elem
} with
{
variant "name ‘E46’ as uncapitalized";
variant “anyElement ‘elem’ except
unqualified,’http://www.organization.org/ttcn/wildcard’”;
};
type record E46b
{
record of XSD.String
elem_list
} with
{
variant "name ‘E46’ as uncapitalized";
variant “anyElement ‘elem_list’ except unqualified”;
};
7.8
annotation
An annotation is used to include additional information in the XSD data. Annotations may appear in every component
and will be mapped to a corresponding comment in TTCN-3. The comment should appear in the TTCN-3 code just
before the mapped structure that it belongs to. This standard does not describe a format in which the comment is to be
put into the TTCN-3 code. An example may look like:
<annotation>
<appinfo>Note</appinfo>
<documentation xml:lang="en">This a helping note!</documentation>
</annotation>
And could translate to
/* Note: This is a helping note ! */
ETSI
53
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Annex A (normative): XSDAUX.ttcn3 XSD.ttcn3
module XSDAUX XSD {
//anySimpleType
type XMLCompatibleString AnySimpleType with {
variant "XSD:anySimpleType"
};
//anyType;
type record AnyType
{
record of String attr,
record of String elem_list
} with {
variant "XSD:anyType";
variant "anyAttributes ‘attr’";
variant "anyElement ‘elem_list’”;
};
// String types
type charstring string XMLCompatibleString String with {
extension variant "XSD:string"
};
type charstring normalizedString XMLStringWithNoCRLFHT NormalizedString (pattern
"[^\n\r\t]#(0,)") with {
extension variant "XSD:normalizedString"
};
type charstring token NormalizedString Token (pattern "([^ \t\r\n]#(1,)( [^
\t\r\n]#(1,))#(0,))|") with {
extension variant "XSD:token"
};
type charstring XMLStringWithNoWhitespace Name (pattern "[\w_:]#(1,)[\w\d_:-.]#(0,)") with {
extension variant "XSD:Name"
};
type charstring XMLStringWithNoWhitespace NMTOKEN (pattern "[\d\w_.:-]#(0,)") with {
extension variant "XSD:NMTOKEN"
};
type charstring Name NCName (pattern "[a-zA-Z_]#1[\w_-.]#(0,)") with {
extension variant "XSD:NCName"
};
type charstring NCName ID (pattern {"[\w_]#(1,)[\w\d_-.]#(0,)") with {
extension variant "XSD:ID"
};
type charstring NCName IDREF (pattern "[\w_]#(1,)[\w\d_-.]#(0,)") with {
extension variant "XSD:IDREF"
};
type charstring NCName ENTITY (pattern "[\w_]#(1,)[\w\d_-.]#(0,)") with {
extension variant "XSD:ENTITY"
};
type octetstring hexBinary HexBinary with {
extension variant "XSD:hexBinary"
};
type charstring base64Binary (pattern "([0-9]|[a-z]|[A-Z]|\ + |/)#(0,)") with {
extension "XSD:base64Binary"
};
type octetstring Base64Binary with {
variant "XSD:base64Binary";
};
type charstring anyURI XMLStringWithNoCRLFHT AnyURI with {
extension variant "XSD:anyURI"
};
type charstring languageXSD Language (pattern "[a-zA-Z]#(1,8)(-[\w]#(1,8))#(0,)") with {
ETSI
54
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
extension variant "XSD:language"
};
// Integer types
type integer integer_ Integer with {
extension variant "XSD:integer"
};
type integer positiveInteger PositiveInteger(1 .. infinity) with {
extension variant "XSD:positiveInteger"
};
type integer nonPositiveInteger NonPositiveInteger (-infinity .. 0) with {
extension variant "XSD:nonPositiveInteger"
};
type integer nonPositiveInteger NegativeInteger (-infinity .. -1) with {
extension variant "XSD:negativeInteger"
};
type integer nonNegativeInteger NonNegativeInteger
extension variant "XSD:nonNegativeInteger"
};
(0 .. infinity) with {
type longlong long_ Long with {
extension variant "XSD:long"
};
type unsignedlonglong unsignedLong UnsignedLong with {
extension variant "XSD:unsignedLong"
};
type long int Int with {
extension variant "XSD:int"
};
type unsignedlong unsignedInt UnsignedInt with {
extension variant "XSD:unsignedInt"
};
type short short_ Short with {
extension variant "XSD:short"
};
type unsignedshort unsignedShort UnsignedShort with {
extension variant "XSD:unsignedShort"
};
type byte byte_ Byte with {
extension variant "XSD:byte"
};
type unsignedbyte unsignedByte UnsignedByte
extension variant "XSD:unsignedByte"
};
with {
// Float types
type float decimal Decimal with {
extension variant "XSD:decimal"
};
type IEEE754float float_ Float with {
extension variant "XSD:float"
};
type IEEE754double double Double with {
extension variant "XSD:double"
};
// Time types
type charstring duration Duration (pattern "-?P([\d]+Y)#(0,)([\d]+M)#(0,1)([\d]+D)#(0,1)
(T([\d]+H)#(0,1)([\d]+M)#(0,1)([\d]+(.[\d]+)#(0,1)S)#(0,1))#(0,1)") with {
extension variant "XSD:duration"
};
ETSI
55
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
type charstring dateTime DateTime (pattern "-?[\d]#(4)-((0[1-9])|[10-12])-((0[1-9])|[1031])T((0[1-9])|[10-23]):((0[1-9])|[10-59]):((0[1-9])|[10-59])(.[\d]+)#(0,1)([+]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:dateTime"
};
type charstring time Time (pattern "((0[1-9])|[10-23]):((0[1-9])|[10-59]):((0[1-9])|[1059])(.[\d]+)#(0,1)([+-]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:time"
};
type charstring date Date (pattern "-?[\d]#(4)-((0[1-9])|[10-12])-((0[1-9])|[10-31])([+]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:date"
};
type charstring gYearMonth GYearMonth (pattern "[\d]#(4)-((0[1-9])|[10-12])([+]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:gYearMonth"
};
type charstring gYear GYear (pattern "-?\d#(4)([+-]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:gYear"
};
type charstring gMonthDay GMonthDay(pattern "--((0[1-9])|[10-12])-((0[1-9])|[10-31])([+]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:gMonthDay"
};
type charstring gDay GDay (pattern "---((0[1-9])|[10-31])([+-]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:gDay"
};
type charstring gMonth GMonth (pattern "--((0[1-9])|[10-12])([+-]?[\d:Z]+)#(0,1)") with {
extension variant "XSD:gMonth"
};
// Sequence types
type set record of NMTOKEN NMTOKENS with {
extension variant "XSD:NMTOKENS"
};
type set record of IDREF IDREFS with {
extension variant "XSD:IDREFS"
};
type set record of ENTITY ENTITIES with {
extension variant "XSD:ENTITIES"
};
type charstring QName with {
extension "XSD:QName"
};
type record QName
{
AnyURI uri
optional,
NCName name
}with {
variant "XSD:QName"
};
// Boolean type
type boolean boolean_ Boolean with {
extension variant "XSD:boolean"
};
//TTCN-3 type definitions supporting the mapping of W3C XML Schema built-in datatypes
type utf8string XMLCompatibleString
(
char(0,0,0,9).. char(0,0,0,9),
char(0,0,0,10)..char(0,0,0,10),
char(0,0,0,12)..char(0,0,0,12),
char(0,0,0,32)..char(0,0,215,255),
char(0,0,224,0)..char(0,0,255,253),
char(0,1,0,0)..char(0,16,255,253)
ETSI
56
)
type utf8string XMLStringWithNoWhitespace
(
char(0,0,0,33)..char(0,0,215,255),
char(0,0,224,0)..char(0,0,255,253),
char(0,1,0,0)..char(0,16,255,253)
)
type utf8string XMLStringWithNoCRLFHT
(
char(0,0,0,32)..char(0,0,215,255),
char(0,0,224,0)..char(0,0,255,253),
char(0,1,0,0)..char(0,16,255,253)
)
}//end module
ETSI
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
57
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Annex B (informative): Examples
The following examples show how a mapping would look like for example XML Schemas. It is only intended to give
an impression of how the different elements have to be mapped and used in TTCN-3.
Example 1
XML Schema:
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- This is an embedded example. An element with a sequence body and an attribute.
The sequence body is formed of elements, two of them are also complexTypes.-->
<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
<xs:element name="orderperson" type="xs:string"/>
<xs:element name="shipto">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="item" >
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string" minOccurs="0"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name="orderid" type="xs:string" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
TTCN-3 Module:
module Example1 {
import from XSDAUX all;
type record ANONYM1__sequence {
XSDAUX.string name,
XSDAUX.string ADDRESS,
XSDAUX.string city,
XSDAUX.string country
}
type record ANONYM2__sequence {
XSDAUX.string title,
XSDAUX.string note optional,
XSDAUX.positiveInteger quantity,
XSDAUX.decimal price
}
type record ANONYM3__sequence {
XSDAUX.string orderperson,
ANONYM1__sequence shipto,
ANONYM2__sequence item
}
ETSI
58
type set ANONYM4__complexType {
ANONYM3__sequence content,
XSDAUX.string orderid
} with {
extension "Attribute: orderid"
}
type ANONYM4__complexType shiporder;
}
module Example1 {
import from XSD all;
type record Shiporder {
XSD.String orderid,
XSD.String orderperson,
record
{
XSD.String name,
XSD.String addressField,
XSD.String city,
XSD.String country
} shipto,
record
{
XSD.String title,
XSD.String note optional,
XSD.PositiveInteger quantity,
XSD.Decimal price
} item
} with {
variant
variant
}
"name ‘Shiporder’ as uncapitalized";
"attribute ‘orderid’";
} with {
encode “XML”;
}
module Example1Template {
import from XSD all;
import from Example1 all;
template Shiporder t_Shiporder:={
orderid:=”18920320_17”,
orderperson:=”Dr. Watson”,
shipto:=
{
name:=”Sherlock Holmes”,
addressField:=”Baker Street 221B”,
city:=”London”,
country:=”England”
},
item:=
{
title:=”Memoirs”,
note:= omit,
quantity:=2,
price:=3.5
}
}
}//end module
ETSI
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
59
<?xml version=”1.0” encoding=”UTF-8”?>
<shiporder orderid=18920320_17>
<orderperson>Dr.Watson</orderperson>
<shipto>
<name>Sherlock Holmes</name>
<address>Baker Street 221B</address>
<city>London</city>
<country>England</country>
</shipto>
<item>
<title>Memoirs</title>
<quantity>2</ quantity >
<price>3.5</ price >
</item>
</shiporder>
ETSI
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
60
Example 2
XML Schema:
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:simpleType name="S1">
<xs:restriction base="xs:integer">
<xs:maxInclusive value="2"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="S2">
<xs:restriction base="S1">
<xs:minInclusive value="-23"/>
<xs:maxInclusive value="1"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="S3">
<xs:restriction base="S2">
<xs:minInclusive value="-3"/>
<xs:maxExclusive value="1"/>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="C1">
<xs:simpleContent>
<xs:extension base="S3">
<xs:attribute name="A1" type="xs:integer"/>
<xs:attribute name="A2" type="xs:float"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:schema>
TTCN-3 Module:
module Example2 {
import from XSDAUX all;
type XSDAUX.integer_ S1__simpleType (-infinity .. 2);
type S1__simpleType S2__simpleType (-23 .. 1);
type S2__simpleType S3__simpleType (-3 .. 0);
type set C1__complexType {
S3__simpleType base,
XSDAUX.integer_ A1 optional,
XSDAUX.float_ A2 optional
} with {
extension "Attribute: A1, A2"
}
}
module Example2 {
import from XSD all;
type XSD.Integer S1 (-infinity .. 2);
type S1 S2 (-23 .. 1);
type S2 S3 (-3 .. 0);
type record C1 {
S3
base,
XSD.Integer
a1 optional,
XSD.Float
a2 optional
} with {
variant "name ‘a1’, ‘a2’ as capitalized";
variant "attribute ‘a1’, ‘a2’";
variant "untagged ‘base’"
}
ETSI
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
61
} with {
encode “XML”;
}
module Example2Templates {
import from XSD all;
import from Example2 all;
template
base
a1
a2
}
t_C1:= {
:=-1,
:=1,
:=2.0
}
<?xml version=”1.0” encoding=”UTF-8”?>
<C1 A1=1 A2=2.0>-1</C1>
ETSI
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
62
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Example 3
XML Schema:
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="nsA" targetNamespace="nsA">
<xs:complexType name="C1">
<xs:simpleContent>
<xs:extension base="xs:integer">
<xs:attribute name="A1" type="xs:integer"/>
<xs:attribute name="A2" type="xs:integer"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexType name="C2">
<xs:simpleContent>
<xs:restriction base="C1">
<xs:minInclusive value="23"/>
<xs:maxInclusive value="26"/>
<xs:attribute name="A1" type="xs:byte" use="required"/>
<xs:attribute name="A2" type="xs:negativeInteger"/>
</xs:restriction>
</xs:simpleContent>
</xs:complexType>
<xs:complexType name="C3">
<xs:simpleContent>
<xs:restriction base="C2">
<xs:minInclusive value="25"/>
<xs:maxInclusive value="26"/>
</xs:restriction>
</xs:simpleContent>
</xs:complexType>
</xs:schema>
TTCN-3 Module:
module Example3 {
import from XSDAUX all;
type set nsA_C1_complexType {
XSDAUX.integer_ base,
XSDAUX.integer_ A1 optional,
XSDAUX.integer_ A2 optional
} with {
extension "Attribute: A1, A2"
}
type XSDAUX.integer_ ANONYM1_simpleType (23 .. 26);
type set nsA_C2_complexType {
ANONYM1_simpleType base,
XSDAUX.byte_ A1,
XSDAUX.negativeInteger A2 optional
} with {
extension "Attribute: A1, A2"
}
type XSDAUX.integer_ nsA_C3_complexType (25 .. 26);
}
module Example3 {
import from XSD all;
type record C1 {
XSD.Integer base,
XSD.Integer a1 optional,
XSD.Integer a2 optional
} with {
variant "attribute ‘a1’, ‘a2’";
variant "untagged ‘base’";
}
ETSI
63
type record C2 {
XSD.Integer (23 .. 26) base,
XSD.Byte
a1,
XSD.NegativeInteger
a2 optional
} with {
variant "attribute ‘a1’, ‘a2’";
variant "untagged ‘base’" ;
}
type record C3 {
XSD.Integer (25 .. 26) base,
XSD.Byte
a1,
XSD.NegativeInteger
a2 optional
} with {
variant "attribute ‘a1’, ‘a2’";
variant "untagged ‘base’"
}
} with {
encode “XML”;
variant "name all, all in all as capitalized";
variant “namespace all as ‘nsA’ “
}
module Example3Templates {
import from XSD all;
import from Example3 all;
template
base
a1
a2
}
t_C1:= {
:=-1000,
:=1,
:=2
template
base
a1
a2
}
t_C2:= {
:=24,
:=1,
:=-2
template
base
a1
a2
}
t_C3:= {
:=25,
:=1,
:=-1000
}
<?xml version=”1.0” encoding=”UTF-8”?>
<C1 xmlns=”nsA” A1=1 A2=2>-1000</C1>
<?xml version=”1.0” encoding=”UTF-8”?>
<C2 xmlns=”nsA” A1=1 A2=-2>24</C2>
<?xml version=”1.0” encoding=”UTF-8”?>
<C3 xmlns=”nsA” A1=1 A2=-1000>25</C3>
ETSI
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
64
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Example 4
XML Schema:
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:NA="nsA"
<xs:include schemaLocation="Example3.xsd"/>
<xs:import schemaLocation="Example2.xsd"/>
<xs:complexType name="newC1">
<xs:complexContent>
<xs:extension base="NA:C1"/>
</xs:complexContent>
</xs:complexType>
<xs:simpleType name="newS1">
<xs:restriction base="S1"/>
</xs:simpleType>
</xs:schema>
TTCN-3 Module:
module Example4 {
import from XSDAUX all;
import from Example2 language "XMLSchema" all;
import from Example3 language "XMLSchema" all;
type Example3.nsA_C1__complexType nsA_newC1__complexType;
type Example2.S1__simpleType nsA_newS1__simpleType;
}
module Example4 {
import from XSD all;
import from Example2 language "XMLSchema" all;
import from Example3 language "XMLSchema" all;
type Example3.C1 NewC1
type Example2.S1
} with {
encode “XML”;
variant "name all as uncapitalized";
variant “namespace all as ‘nsA’ prefix ‘NA’“
}
module Example4Templates {
import
import
import
import
from
from
from
from
XSD all;
Example2 language "XMLSchema" all;
Example3 language "XMLSchema" all;
Example4 all;
template t_NewC1:= {
base :=-1000,
a1
:=1,
a2
:=2
}
template NewS1:=1
}
<?xml version=”1.0” encoding=”UTF-8”?>
<NA:newC1 xmlns:NA=”nsA” A1=1 A2=2>-1000</NA:newC1>
<?xml version=”1.0” encoding=”UTF-8”?>
<NA:newS1 xmlns:NA=”nsA”>1</NA:newS1>
ETSI
targetNamespace="nsA">
65
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Annex C (normative): List of reserved keywords
To be completed.
ETSI
66
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)
Annex D (normative): List and specification of encoding
extension attributes
To be completed.
ETSI
67
Annex E (informative): History
Document history
V1.0.0
March 2004
ToC
V1.0.0
March 2005
First stable draft
V1.0.0
July 2006
Corrected Draft
V1.0.0
October 2006
Finalised Draft
V1.0.0
May 2007
Aligned with ITU-T Rec. X.694
ETSI
ETSI ES/MTS-201 873-9 V0.2.0 (2007-05)