ISO/TS 10303-35:2003

TECHNICAL ISO/TS
SPECIFICATION 10303-35
First edition
2003-12-15
Industrial automation systems and
integration — Product data
representation and exchange —
Part 35:
Conformance testing methodology and
framework: Abstract test methods for
standard data access interface (SDAI)
implementations
Systèmes d'automatisation industrielle et intégration — Représentation
et échange de données de produits —
Partie 35: Méthodologie et cadre pour les essais de conformité:
Méthodes d'essai abstraites pour mises en application SDAI

Reference number
©
ISO 2003
PDF disclaimer
This PDF file may contain embedded typefaces. In accordance with Adobe's licensing policy, this file may be printed or viewed but
shall not be edited unless the typefaces which are embedded are licensed to and installed on the computer performing the editing. In
downloading this file, parties accept therein the responsibility of not infringing Adobe's licensing policy. The ISO Central Secretariat
accepts no liability in this area.
Adobe is a trademark of Adobe Systems Incorporated.
Details of the software products used to create this PDF file can be found in the General Info relative to the file; the PDF-creation
parameters were optimized for printing. Every care has been taken to ensure that the file is suitable for use by ISO member bodies. In
the unlikely event that a problem relating to it is found, please inform the Central Secretariat at the address given below.

©  ISO 2003
All rights reserved. Unless otherwise specified, no part of this publication may be reproduced or utilized in any form or by any means,
electronic or mechanical, including photocopying and microfilm, without permission in writing from either ISO at the address below or
ISO's member body in the country of the requester.
ISO copyright office
Case postale 56 • CH-1211 Geneva 20
Tel. + 41 22 749 01 11
Fax + 41 22 749 09 47
E-mail copyright@iso.org
Web www.iso.org
Published in Switzerland
ii © ISO 2003 — All rights reserved

Contents Page
1 Scope .1
2 Normative references.1
3 Terms, definitions, and abbreviations .2
3.1 Terms defined in ISO 10303-1 .2
3.2 Terms defined in ISO 10303-22 .2
3.3 Terms defined in ISO 10303-31 .3
3.4 Other terms and definitions .4
3.5 Abbreviations .4
4 Overview and characteristics .4
4.1 Testing characteristics .5
5 Testing process .5
5.1 Preparation for testing .6
5.2 Test campaign.6
5.3 Test conclusion.6
5.4 Test report production .6
6 SDAI abstract test schema .7
6.1 Introduction .7
6.2 SDAI abstract test schema function and procedure definitions .8
7 SDAI operation schema .156
7.1 SDAI operation schema constant definitions.157
7.2 SDAI operation schema function and procedure definitions .158
8  EXPRESS structure test schema.188

Annex A (normative) Information object registration .191

Index       .192

Foreword
ISO (the International Organization for Standardization) is a worldwide federation of national standards
bodies (ISO member bodies). The work of preparing International Standards is normally carried out
through ISO technical committees. Each member body interested in a subject for which a technical
committee has been established has the right to be represented on that committee. International
organizations, governmental and non-governmental, in liaison with ISO, also take part in the work. ISO
collaborates closely with the International Electrotechnical Commission (IEC) on all matters of
electrotechnical standardization.

International Standards are drafted in accordance with the rules given in the ISO/IEC Directives, Part 2.

The main task of technical committees is to prepare International Standards. Draft International
Standards adopted by the technical committees are circulated to the member bodies for voting.
Publication as an International Standard requires approval by at least 75 % of the member bodies
casting a vote.
In other circumstances, particularly when there is an urgent market requirement for such documents, a
technical committee may decide to publish other types of normative document:

— an ISO Publicly Available Specification (ISO/PAS) represents an agreement between technical
experts in an ISO working group and is accepted for publication if it is approved by more than 50
% of the members of the parent committee casting a vote;

— an ISO Technical Specification (ISO/TS) represents an agreement between the members of a
technical committee and is accepted for publication if it is approved by 2/3 of the members of the
committee casting a vote.
An ISO/PAS or ISO/TS is reviewed after three years in order to decide whether it will be confirmed for
a further three years, revised to become an International Standard, or withdrawn. If the ISO/PAS or
ISO/TS is confirmed, it is reviewed again after a further three years, at which time it must either be
transformed into an International Standard or be withdrawn.

Attention is drawn to the possibility that some of the elements of this document may be the subject of
patent rights. ISO shall not be held responsible for identifying any or all such patent rights.

ISO/TS 10303-35 was prepared by Technical Committee ISO/TC 184, Industrial automation
systems and integration, Subcommittee SC 4, Industrial data.

ISO 10303 is organized as a series of parts, each published separately. The structure of ISO 10303 is
described in ISO 10303-1.
Each part of ISO 10303 is a member of one of the following series: description methods,
implementation methods, conformance testing methodology and framework, integrated generic
resources, integrated application resources, application protocols, abstract test suites, application
interpreted constructs, and application modules. This part is a member of the conformance testing
ethodology and framework series.

A complete list of parts of ISO 10303 is available from the Internet:

http://www.tc184-sc4.org/titles/

iv © ISO 2003 — All rights reserved

Introduction
ISO 10303 is an International Standard for the computer-interpretable representation of product in-
formation and for the exchange of product data. The objective is to provide a neutral mechanism
capable of describing products throughout their life cycle. This mechanism is suitable not only for
neutral file exchange, but also as a basis for implementing and sharing product databases, and as a basis
for archiving.
This part of ISO 10303 is a member of the conformance testing methodology and framework series. It
specifies the abstract test methods for SDAI implementations. SDAI is the standard data access
interface specification to data that has been defined using ISO 10303-11. SDAI is specified in ISO
10303-22. This part follows the general concepts of conformance testing defined in ISO 10303-31.

Major subdivisions in this part of ISO 10303 are:

— Abstract test cases, groups, suite and verdict criteria in clause 6;

— SDAI operations wrapped in EXPRESS procedures and functions with verdict criteria in clause 7;

— The EXPRESS structure test schema ESTS as the target for the abstract test cases in clause 8.

TECHNICAL SPECIFICATION ISO/TS 10303-35:2003(E)

Industrial automation systems and integration — Product data
representation and exchange —
Part 35:
Conformance testing methodology and framework: Abstract test
methods for standard data access interface (SDAI)
implementations
1 Scope
This part of ISO 10303 specifies the abstract test methods and requirements for conformance testing of
an implementation of a language binding of the SDAI. Since the SDAI is specified independently of
any programming language, the abstract test methods presented in this part are applicable to all SDAI
language bindings. The abstract test methods support as well the various implementation classes as
specified in ISO 10303-22.
The following are within the scope of this part of ISO 10303:

— abstract test methods for software systems that implement the SDAI;

— the specification, in a manner that is independent of any SDAI language binding, of the methods
and approaches for testing of various SDAI operations;

— the specification and documentation of abstract test cases.

The following are outside the scope of this part of ISO 10303:

— the development of test data and/or test programs for specific language bindings;

— the specification of test methods, algorithms, or programs for the conformance testing of
applications that interact with SDAI implementations;

— the architecture and implementation approach for a conformance test system that realizes the test
methods specified in this part of ISO 10303.
2 Normative references
The following referenced documents are indispensable for the application of this document. For dated
references, only the edition cited applies. For undated references, the latest edition of the referenced
document (including any amendments) applies.

ISO 10303-1:1994, Industrial automation systems and integration — Product data representation
and exchange — Part 1: Overview and fundamental principles

ISO 10303-11:1994, Industrial automation systems and integration — Product data representation
and exchange — Part 11: Description methods: The EXPRESS language reference manual
ISO 10303-21:2002, Industrial automation systems and integration — Product data representation
and exchange — Part 21: Implementation methods: Clear text encoding of the exchange structure

ISO 10303-22:1998, Industrial automation systems and integration — Product data representation
and exchange — Part 22: Implementation methods: Standard data access interface

ISO 10303-31:1994, Industrial automation systems and integration — Product data representation
and exchange — Part 31: Conformance testing methodology and framework: General concepts

ISO 10303-32:1998, Industrial automation systems and integration — Product data representation
and exchange — Part 32: Conformance testing methodology and framework: Requirements on testing
laboratories and clients
3 Terms, definitions, and abbreviations
3.1 Terms defined in ISO 10303-1
For the purpose of this document, the following terms defined in ISO 10303-1 apply:

— abstract test suite;
— application protocol;
— conformance class;
— implementation method;
— PICS proforma;
— protocol implementation conformance statement (PICS).
3.2 Terms defined in ISO 10303-22
For the purpose of this document, the following terms defined in ISO 10303-22 apply:

— application schema;
— implementation class;
— repository;
— schema instance;
— SDAI language binding;
— SDAI-model;
— session;
— validation.
2 © ISO 2003 — All rights reserved

3.3 Terms defined in ISO 10303-31
For the purpose of this document, the following terms defined in ISO 10303-31 apply:

— abstract test case (ATC);
— abstract test group;
— abstract test method;
— conformance;
— conformance log;
— (conformance) test report;
— conformance testing;
— executable test case;
— executable test suite;
— fail (verdict);
— implementation under test (IUT);

— inconclusive (verdict);
— pass (verdict);
— PIXIT proforma;
— Protocol Implementation eXtra Information for Testing (PIXIT);

— test campaign;
— test case error;
— testing laboratory;
— test purpose;
— test report;
— (test) verdict;
— verdict criteria.
3.4 Other terms and definitions
For the purpose of this document, the following definitions apply:

3.4.1
abstract test operation
a function or procedure that encapsulate an SDAI operation to test its proper behaviour, including the
possible error code and error base. An abstract test operation is a verdict criterion operation

3.4.2
executable test operation
an instantiation of an abstract test operation for a particular programming language and SDAI
implementation.
3.4.3
SDAI operation
an operation defined in clause 10 of ISO10303-22:1998

3.4.4
verdict criterion operation
a function or procedure defining a verdict criterion
3.5 Abbreviations
For the purposes of this document, the following abbreviations apply.

IUT Implementation Under Test

PICS Protocol Implementation Conformance Statement

PIXIT Protocol Implementation eXtra Information for Testing

SDAI Standard Data Access Interface, ISO 10303-22

ESTS EXPRESS Structure Test Schema
4 Overview and characteristics
This part of ISO 10303 describes abstract test methods that conformance test systems would implement
in order to test SDAI implementations. General principles and an overall framework for conformance
testing are provided in ISO 10303-31. Requirements on test laboratories are defined in ISO 10303-32.
The methods for preparing, controlling, observing and analysing implementations during testing are
defined in this part of ISO 10303.

Abstract test methods are given for the SDAI implementation classes 1 to 7. An abstract test method is
a set of instructions on how to apply specified abstract test cases for particular SDAI implementations.
The abstract test cases are grouped into abstract test groups with the SDAI abstract test suite at the top
level. The abstract test cases adjust themselves to the actual implementation class by accessing the
information in the object, representing an instance of entity type implementation (see ISO 10303-22,
7.4.2).
4 © ISO 2003 — All rights reserved

The abstract test suite for SDAI implementations is defined by EXPRESS functions and procedures.
For conformance testing an executable test suite has to be derived from the abstract test suite, suitable
for the underlying programming language of the SDAI implementation.

NOTE This part of ISO 10303 does not specify how to derive an executable test suite from the
abstract test suite. This is the task of a testing laboratory or its client.

Clause 8 defines the EXPRESS Structure Test Schema (ESTS) as the basic application schema
operated by the IUT. The abstract test suite in clause 6 specifies test cases and verdict criteria for
particular entities and attributes of the ESTS. The test cases and verdict criteria refer to the "wrapper"
functions and procedures for the SDAI operations in clause 6.
4.1 Testing characteristics
The characteristics of the test methods specified in this part of ISO 10303 are:

— An SDAI implementation may be early bound, late bound, or both. Test methods specified in this
part of ISO 10303 address all such implementations;

— An SDAI implementation obeys the state model described in ISO 10303-22. The specified tests
ensure this;
— ISO 10303-22 is written independent of any programming language. To keep the language
independence this part of ISO 10303 is using EXPRESS to specify the abstract tests;

— SDAI operations provide means for data manipulation and transactions. Testing these operations
will provide assurance of their correctness and whether they had the desired effect on the persistent
storage. These operations include create, delete, modify, validate and various manipulation
operations that act on schema instances, SDAI-models, and instances of application schema
entities;
— In situations of error, SDAI operations return error codes. Testing will encompass all reasonable
error situations for an operation to ensure that appropriate error codes are returned;

— The testing of error handling requires checking the returned error value against the actual error
condition that triggered that return value;

— Environment and session operations provide the capability for changing the state of the SDAI
session. Conformance testing will ascertain that only the permitted transitions take place and that
only permitted operations for a state are allowed;

— Aggregate operations play important roles in SDAI implementations, facilitating the successful
completion of other complex operations or sequences of operations;

— Test purposes and verdicts criteria are provided for all test cases;

— Specification of the conformance log along with the test purpose and verdict criteria definitions.
5 Testing process
The testing process consists of the preparation of the test, running the campaign, making a conclusion
and producing the final test report.
5.1 Preparation for testing
PICS and PIXIT proformas are completed by IUT vendors prior to testing. The PICS shall be based on
the PICS proforma of ISO 10303-22, Annex B. The PICS shall further specify:

— the SDAI language binding;
— the binding style: late binding and/or early binding as defined in the particular SDAI language
binding.
An executable test suite, derived from the abstract test suite in clause 6 and the abstract test operations
in clause 7 shall be available.

The application schema ESTS shall be made available to the IUT.

NOTE The way how an application schema is made available to an SDAI implementation is usually
implementation dependent.
The SDAI entity implementation contains information that shall match to the PICS. This information
is printed into the conformance log by the abstract test case atc_implementation (see 6.3).
5.2 Test campaign
A conformance test campaign is a sequenced execution of all required executable test cases (ETCs)
starting from the executable test suite. The results of this sequenced execution determines
conformance.
Modifications to the IUT are not permitted during a test campaign. Modifications to the ETCs or to the
sequence of their execution is not permitted during a test campaign, except in the situation where the
ETC is determined to be in error.

If an ETC is determined to be in error, a verdict of INCONCLUSIVE shall be assigned to its execution
until the error is resolved and the test repeated.
5.3 Test conclusion
A test campaign may terminate for any reason. A normal termination of a test campaign occurs when
all its executable tests have been run. A PASS verdict shall be assigned to a campaign if all the tests of
the campaign have returned PASS verdicts and no violation of any ISO 10303 part is detected.
5.4 Test report production
A conformance test report shall be created after a test campaign terminates. In addition to the
requirements specified in ISO 10303-31 and ISO 10303-32 this report shall contain:

— used programming language;
— type of tested SDAI language binding, late binding or early binding;

— tested SDAI implementation classes;

— the executable test suite being used;

6 © ISO 2003 — All rights reserved

— a detailed conformance log as specified in clause 6.

Any relevant information on the testing environment shall be included as well.
6 SDAI abstract test schema
This clause specifies the SDAI_abstract_test_schema containing the abstract test cases for SDAI
implementations formulated in a hierarchical manner. A test campaign starts with the
SDAI_abstract_test_suite procedure (see 6.1). From this root node other abstract test groups and
abstract test cases are invoked.

The following EXPRESS specification begins the SDAI abstract test schema.
EXPRESS specification:
*)
SCHEMA SDAI_abstract_test_schema;
USE FROM SDAI_dictionary_schema; -- ISO 10303-22
USE FROM SDAI_population_schema; -- ISO 10303-22
USE FROM SDAI_session_schema; -- ISO 10303-22
USE FROM SDAI_parameter_data_schema; -- ISO 10303-22
REFERENCE FROM SDAI_operation_schema; -- ISO 10303-35
USE FROM ESTS; -- ISO 10303-35
(*
NOTE The schemas referenced above are specified in the following parts of ISO 10303:

SDAI_dictionary_schema ISO 10303-22

SDAI_population_schema ISO 10303-22

SDAI_session_schema ISO 10303-22

SDAI_parameter_data_schema ISO 10303-22

SDAI_ operation_schema Clause 7 of this part of ISO 10303

ESTS Clause 8 of this part of ISO 10303

6.1 Introduction
The subject of the SDAI_abstract_test_schema is to define abstract test cases for testing SDAI
implementations. An abstract test case specifies one or several test purposes, verdict criterion
operations and verdict statements. The structure of an abstract test case is as follows:

— preparation of test data;
— writing the name of the abstract test case in the conformance log with the atc procedure (see
6.164);
— writing the description of a test purpose to the conformance log with the purpose procedure (see
1.165);
— performing one or several verdict criterion operations. The verdict criterion operations are assert
(see 6.2.162), check_instance (see 6.2.163), and the executable test operations (see 7.2);

— assigning a verdict of the test purpose, based on the results of the verdict criteria. This is
accomplished by invoking the verdict procedure (see 6.2.166) that writes the verdict result to the
conformance log.
Some abstract test cases are dependent of the supported implementation levels, as defined in the
implementation object. Whenever an SDAI operation is dependent on a specific implementation level,
the EXPRESS algorithms query this information in order to determine if the test case is applicable to
the implementation under test.

The abstract test cases specified in this clause are built around SDAI operations specified in ISO
10303-22. For conformance testing executable test cases shall be derived from the abstracted test cases
to build up an equivalent executable test suite. Since there exists no guaranteed one-to-one relationship
between operations in ISO 10303-22 and a particular SDAI language binding, the statements of a
executable test case may not be identical to those in the abstract test case. However the statements of an
executable test case shall reflect the logical structure of its abstract test case, defined by the test
purposes and the specified verdict criteria. The executable test cases shall also follow the specifications
of the corresponding SDAI language bindings defined in other parts of ISO 10303. SDAI language
bindings may specify modified or extended functionality for some SDAI operations to that defined in
ISO 10303-22. In the case that the specifications in an SDAI language binding conflicts with the ones
given in ISO 10303-22, the executable test cases shall be adopted for the specifications of the SDAI
language bindings.
Attributes of the session and population entities sdai_session, sdai_transaction, implementation,
sdai_repository, sdai_repository_contents, sdai_model, sdai_model_contents, entity_extent and
schema_instance are accessed by usual EXPRESS expressions. All application entities and attributes of
the ESTS schema are accessed by the abstract test operations only.
6.2 SDAI abstract test schema function and procedure definitions
The root of the abstract test suite is given by the SDAI_abstract_test_suite procedure (see 6.2.1).
From this root node other procedures and functions, representing the abstract test groups and
abstract test cases are invoked.

Abbreviated names are used in the identifiers of the functions and procedures declared in this schema.
Prefixes used in these identifiers have the following meanings:

atg abstract test group
atc abstract test case
Further auxiliary functions and procedures are defined to prepare test data, generate the conformance
log and establish the verdict criteria.

Functions with the prefix 'macro' are used to prepare the IUT for a specific state. The specified macros
are:
8 © ISO 2003 — All rights reserved

— macro_get_closed_repository (see 6.2.147);

— macro_get_open_repository (see 6.2.148);

— macro_get_schema_instance (see 6.2.149);

— macro_get_sdai_model_unset_mode (see 6.2.150);

— macro_get_sdai_model_read_only (see 6.2.151);

— macro_get_sdai_model_read_write (see 6.2.152);

— macro_get_sdai_model_read_write_different (see 6.2.153);

— macro_get_data_dictionary_model (see 6.2.154);

— macro_get_entity_extent (see 6.2.155);

— macro_check_extent_if_populated (see 6.2.156);

— macro_check_instance_if_values_unset (see 6.2.157);

— macro_compare_aggregates (see 6.2.158);

— macro_convert_primitive_to_aggregate (see 6.2.159);

— macro_clear_aggregate (see 6.2.160).

The asp function (see 6.2.161) is used to construct values of type assignable_primitive for testing.

Besides the abstract test operations defined in clause 7 the following procedures participate in the
preparation for the verdict criteria used to establish the verdict:

— assert (see 6.2.162);
— check_instance (see 6.2.163);

— purpose (see 6.2.165);
— verdict (see 6.2.166).
The following procedures are used to generate the conformance log:

— atc (see 6.2.164);
— purpose (see 6.2.165);
— verdict (see 6.2.166);
— print (see 6.2.167).
6.2.1 SDAI_abstract_test_suite
The SDAI abstract test suite shall be used for the assessment of an SDAI implementation.
EXPRESS specification:
*)
PROCEDURE SDAI_abstract_test_suite;
LOCAL
session : sdai_session;
repo : sdai_repository;
schema_inst : schema_instance;
modl, modl2 : sdai_model;
END_LOCAL;
-- tests on sdai_session
session := atc_open_session;
atc_implementation(session);
repo := macro_get_closed_repository;
atc_close_session(repo);
modl := macro_get_sdai_model_read_write;
atc_create_non_persistent_list(modl);
close_session(session, NO_ERROR, ?);
session := open_session(NO_ERROR, ?);
if (session.sdai_implementation.transaction_level = 3) then
atc_start_transaction_read_only_access(session);
end_if;
close_session(session, NO_ERROR, ?);
session := open_session(NO_ERROR, ?);
if (session.sdai_implementation.transaction_level = 3) then
modl := macro_get_sdai_model_read_write;
atc_commit(modl);
atc_abort(modl);
end_if;
close_session(session, NO_ERROR, ?);
-- tests on sdai_repository
repo := macro_get_closed_repository;
atc_open_repository(repo);
close_session(session, NO_ERROR, ?);
repo := macro_get_closed_repository;
atc_create_sdai_model(repo);
close_session(session, NO_ERROR, ?);
repo := macro_get_open_repository;
atc_create_schema_instance(repo);
close_session(session, NO_ERROR, ?);
repo := macro_get_open_repository;
atc_close_repository(repo);
close_session(session, NO_ERROR, ?);
-- tests on schema_instance
schema_inst := macro_get_schema_instance;
atc_add_sdai_model(schema_inst);
close_session(session, NO_ERROR, ?);
schema_inst := macro_get_schema_instance;
atc_remove_sdai_model(schema_inst);
close_session(session, NO_ERROR, ?);
10 © ISO 2003 — All rights reserved

schema_inst := macro_get_schema_instance;
atc_rename_schema_instance(schema_inst);
close_session(session, NO_ERROR, ?);
schema_inst := macro_get_schema_instance;
atc_delete_schema_instance(schema_inst);
close_session(session, NO_ERROR, ?);
-- tests on sdai_model
modl := macro_get_sdai_model_unset_mode;
atc_start_read_only_access(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_unset_mode;
atc_promote_sdai_model_to_read_write(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_only;
atc_end_read_only_access(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_unset_mode;
atc_start_read_write_access(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
atc_end_read_write_access(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
modl2 := macro_get_sdai_model_read_write_different(modl);
atc_delete_SDAI_model(modl, modl2);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
atc_rename_SDAI_model(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
atc_get_entity_definition(modl);
close_session(session, NO_ERROR, ?);
repo := macro_get_open_repository;
atc_create_entity_instance(repo);
close_session(session, NO_ERROR, ?);
if (session.sdai_implementation.transaction_level = 2) then
repo := macro_get_open_repository;
atc_undo_changes(repo);
atc_save_changes(repo);
close_session(session, NO_ERROR, ?);
end_if;
-- tests on entity type
session := open_session(NO_ERROR, ?);
if (session.sdai_implementation.expression_level >= 2) then
atc_get_complex_entity_definition;
end_if;
atc_is_subtype_of;
close_session(session, NO_ERROR, ?);
-- tests on application entity instance
modl := macro_get_sdai_model_read_write;
atg_attribute_basic(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
modl2 := macro_get_sdai_model_read_write_different(modl);
atc_attribute_entity_instance_in_another_model(modl, modl2);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
modl2 := macro_get_sdai_model_read_write_different(modl);
atc_attribute_entity_instance_in_closed_repository(modl, modl2);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
atc_find_entity_instance_sdai_model(modl);
atc_get_instance_type(modl);
atc_is_instance_of(modl);
atc_is_kind_of(modl);
atc_persistent_label_and_session_identifier(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
atc_find_entity_instance_users(modl);
atc_find_entity_instance_usedin(modl);
atc_find_instance_roles(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
atc_copy_application_instance(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
atc_delete_application_instance(modl);
close_session(session, NO_ERROR, ?);
if (session.sdai_implementation.expression_level >= 2) then
modl := macro_get_sdai_model_read_write;
atc_validate_required_explicit_attributes_assigned(modl);
atc_validate_inverse_attributes(modl);
atc_validate_explicit_attributes_references(modl);
atc_validate_aggregates_size(modl);
atc_validate_aggregates_uniqueness(modl);
atc_validate_array_not_optional(modl);
close_session(session, NO_ERROR, ?);
end_if;
-- tests on aggregate
modl := macro_get_sdai_model_read_write;
atg_aggregate_simple(modl);
close_session(session, NO_ERROR, ?);
modl := macro_get_sdai_model_read_write;
atg_nested_aggregate(modl);
close_session(session, NO_ERROR, ?);
END_PROCEDURE; -- SDAI_abstract_test_suite
(*
6.2.2 atc_open_session
This abstract test case shall be used for the assessment of the implementation of the SDAI operation
open session. The opened sdai_session is returned.
EXPRESS specification:
*)
12 © ISO 2003 — All rights reserved

FUNCTION atc_open_session : sdai_session;
LOCAL
session : sdai_session;
END_LOCAL;
atc('atc_open_session');
purpose('Ensures that open_session works correctly when '
+ 'SDAI session is closed');
session := open_session(NO_ERROR, ?);
verdict;
return (session);
END_FUNCTION; -- atc_open_session
(*
6.2.3 atc_implementation
This abstract test case shall be used for the assessment of the implementation of the SDAI entity
implementation. The implementation information is printed to the conformance log. The printed
implementation class, transaction level, expression level and domain equivalence level shall be
identical to the PICS. The recording level and scope level is not checked by this part of ISO 10303.
EXPRESS specification:
*)
PROCEDURE atc_implementation(session : sdai_session);
LOCAL
imp : implementation := session.sdai_implementation;
END_LOCAL;
print('Implementation Under Test (IUT):');
print(' name='+ imp.name);
print(' level='+ imp.level);
print(' sdai version='+ imp.sdai_version);
print(' binding version='+ imp.binding_version);
print(' implementation class='+ format(imp.implementation_class,''));
print(' transaction level='+ format(imp.transaction_level,''));
print(' expression level='+ format(imp.expression_level,''));
print(' recording level='+ format(imp.recording_level,''));
print(' scope level='+ format(imp.scope_level,''));
print(' domain equivalence level='+
format(imp.domain_equivalence_level,''));
atc('atc_implementation');
purpose('Ensure the correct sdai_version');
assert(imp.sdai_version = '{ iso standard 10303 part(22) version(0) }');
verdict;
purpose('Ensure that the implementation class is valid');
assert(imp.implementation_class >= 1);
assert(imp.implementation_class <= 7);
verdict;
CASE imp.implementation_class OF
1 : BEGIN
purpose('Ensure proper transaction level');
assert(imp.transaction_level = 1);
verdict;
purpose('Ensure proper expression level');
assert(imp.expression_level >= 1);
verdict;
purpose('Ensure proper domain equivalence level');
assert(imp.domain_equivalence_level >= 1);
verdict;
END;
2 : BEGIN
purpose('Ensure proper transaction level');
assert(imp.transaction_level = 1);
verdict;
purpose('Ensure proper expression level');
assert(imp.expression_level >= 2);
verdict;
purpose('Ensure proper domain equivalence level');
assert(imp.domain_equivalence_level >= 1);
verdict;
END;
3 : BEGIN
purpose('Ensure proper transaction level');
assert(imp.transaction_level = 1);
verdict;
purpose('Ensure proper expression level');
assert(imp.expression_level >= 3);
verdict;
purpose('Ensure proper domain equivalence level');
assert(imp.domain_equivalence_level >= 2);
verdict;
END;
4 : BEGIN
purpose('Ensure proper transaction level');
assert(imp.transaction_level = 2);
verdict;
purpose('Ensure proper expression level');
assert(imp.expression_level >= 2);
verdict;
purpose('Ensure proper domain equivalence level');
assert(imp.domain_equivalence_level >= 1);
verdict;
END;
5 : BEGIN
purpose('Ensure proper transaction level');
assert(imp.transaction_level = 3);
verdict;
purpose('Ensure proper expression level');
assert(imp.expression_level >= 2);
verdict;
purpose('Ensure proper domain equivalence level');
assert(imp.domain_equivalence_level >= 1);
verdict;
END;
6 : BEGIN
purpose('Ensure proper transaction level');
assert(imp.transaction_level = 3);
verdict;
purpose('Ensure proper expression level');
assert(imp.expression_level >= 3);
14 © ISO 2003 — All rights reserved

verdict;
purpose('Ensure proper domain equivalence level');
assert(imp.domain_equivalence_level >= 2);
verdict;
END;
7 : BEGIN
purpose('Ensure proper transaction level');
assert(imp.transaction_level = 3);
verdict;
purpose('Ensure proper expression level');
assert(imp.expression_level >= 4);
verdict;
purpose('Ensure proper domain equivalence level');
assert(imp.domain_equivalence_level >= 2);
verdict;
END;
END_CASE;
END_PROCEDURE; -- atc_implementation
(*
Argument definitions:
session: (input) An open SDAI session.
6.2.4 atc_close_session
This abstract test case shall be used for the assessment of the implementation of the SDAI operation
close session.
EXPRESS specification:
*)
PROCEDURE atc_close_session(repo : sdai_repository);
LOCAL
session : sdai_session := repo.session;
END_LOCAL;
atc('atc_close_session');
purpose('Ensures that close_session works correctly when session '
+ 'is open');
close_session(session, NO_ERROR, ?);
verdict;
purpose('ensures that repositories are not available after '
+ 'session was closed');
open_repository(session, repo, RP_NEXS, ?);
verdict;
purpose('ensures that close_session reports an SS_NOPN error when '
+ 'SDAI session is closed');
close_session(session, SS_NOPN, ?);
verdict;
END_PROCEDURE; -- atc_close_session
(*
Argument definitions:
repo: (input) A closed repository (that is, from the known_servers but not active_servers set of the
SDAI session).
6.2.5 atc_create_non_persistent_list
This abstract test case shall be used for the assessment of the implementation of the SDAI operation
create non-persistent list.
EXPRESS specification:
*)
PROCEDURE atc_create_non_persistent_list(modl : sdai_model);
LOCAL
session : sdai_session := modl.repository.session;
non_persist_list : non_persistent_list_instance;
aggr_created : aggregate_instance;
iter : iterator;
inst : application_instance :=
create_entity_instance('ESTS.EPSILON', modl, NO_ERROR, ?);
bool : BOOLEAN;
END_LOCAL;
atc('atc_create_non_persistent_list');
purpose('Ensures that create_non_persistent_list works correctly');
non_persist_list := create_non_persistent_list(NO_ERROR, ?);
verdict;
purpose('Ensures that a non-persistent list is empty after '
+ 'its creation');
assert(get_member_count(non_persist_list, NO_ERROR, ?) = 0);
verdict;
purpose('Prevents assigning a non-persistent list to an attribute of '
+ 'some entity');
put_attribute(inst, 'ESTS.EPSILON.E2', non_persist_list, VT_NVLD, ?);
verdict;
purpose('Ensures that an AI_NVLD error is reported when SET '
+ 'and BAG operations are applied to a non-persistent list');
add_unordered(non_persist_list, asp(inst, ?),
AI_NVLD, non_persist_list);
remove_unordered(non_persist_list, asp(inst, ?),
AI_NVLD, non_persist_list);
aggr_created := create_aggregate_instance_unordered(non_persist_list, ?,
AI_NVLD, non_persist_list);
verdict;
purpose('Ensures that an AI_NVLD error is reported when ARRAY '
+ 'operations are applied to a non-persistent list.');
bool := test_by_index(non_persist_list, 1, AI_NVLD, non_persist_list);
unset_value_by_index(non_persist_list, 1, AI_NVLD, non_persist_list);
iter := create_iterator(non_persist_list, NO_ERROR, ?);
bool := test_current_member(iter, AI_NVLD, non_persist_list);
unset_value_current_member(iter, AI_NVLD, non_persist_list);
verdict;
purpose('Ensures that an AI_NVLD error is reported when any '
+ 'aggregate creation operations disallowed for non-persistent '
+ 'lists are applied.');
aggr_created := create_aggregate_instance_by_index(non_persist_list,
1, ?, AI_NVLD, non_persist_list);
aggr_created := create_aggregate_instance_as_current_member(iter, ?,
16 © ISO 2003 — All rights reserved

AI_NVLD, non_persist_list);
aggr_created := create_aggregate_instance_before_current_member(iter, ?,
AI_NVLD, non_persist_list);
aggr_created := create_aggregate_instance_after_current_member(iter, ?,
AI_NVLD, non_persist_list);
aggr_created := add_aggregate_instance_by_index(non_persist_list, 1, ?,
AI_NVLD, non_persist_list);
verdict;
purpose('Ensures that non-persistent list does not exist after '
+ 'SDAI session is closed.');
close_session(session, NO_ERROR, ?);
add_by_index(non_persist_list, 1, asp(inst, ?), SS_NOPN, ?);
verdict;
END_PROCEDURE; -- atc_create_non_persistent_list
(*
Argument definitions:
modl: (input) An SDAI-model in read-write mode, based on the ESTS schema.
6.2.6 atc_start_transaction_read_only_access
This abstract test case shall be used for the assessment of the implementation of the SDAI operation
start transaction read-only access.
EXPRESS specification:
*)
PROCEDURE atc_start_transaction_read_only_access(session : sdai_session);
LOCAL
transaction : sdai_transaction;
bool : BOOLEAN;
END_LOCAL;
atc('atc_start_transaction_read_only_access');
purpose('Ensures that start_transaction_read_only_access works '
+ 'correctly when session is open and transaction does not exist.');
transaction := start_transaction_read_only_access(session, NO_ERROR, ?);
verdict;
purpose('Ensures that started transaction belongs to '
+ 'the active_transaction set of the session.');
bool := transaction IN session.active_transaction;
assert(bool);
verdict;
purpose('Ensures that start_transaction_read_only_access reports '
+ 'a TR_EXS error when transaction is already started.');
transaction := start_transaction_read_only_access(session, TR_EXS,
transaction);
verdict;
END_PROCEDURE; -- atc_start_transaction_read_only_access
(*
Argument definitions:
session: (input) An open SDAI session.
6.2.7 atc_commit
This abstract test case shall be used for the assessment of the implementation of the SDAI operation
commit.
EXPRESS specification:
*)
PROCEDURE atc_commit(modl : sdai_model);
LOCAL
repo : sdai_repository := modl.repository;
session : sdai_session := repo.session;
transaction : sdai_transaction := session.active_transaction[1];
inst1, inst2 : application_instance;
date : STRING;
label : STRING;
mode : access_type;
END_LOCAL;
atc('atc_commit');
(* Modifying the SDAI-model under consideration by creating some
entity instance *)
inst1 := create_entity_instance('ESTS.OMEGA', modl, NO_ERROR, ?);
(* Saving some data needed for future checkings. *)
date := modl.change_date;
label := get_persistent_label(inst1, NO_ERROR, ?);
mode := transaction.mode;
purpose('Ensures that commit works correctly.');
commit(transaction, NO_ERROR, ?);
verdict;
purpose('Ensures that mode for transaction continues to
...