The principal goal of this document is to help W3C Working Groups to write
clearer, more implementable, and better testable technical reports. It both
provides a common framework for specifying conformance requirements and
definitions, and also addresses the representation of specifications
(technical reports) as schemata, both of which facilitate the generation of
test materials. The material is presented as a set of organizing guidelines
and verifiable checkpoints. This document is one in a family of Framework
documents of the Quality Assurance (QA) Activity, which includes the other existing or
in-progress specifications: Introduction; Operational Guidelines; and, Test
Guidelines.
This section describes the status of this document at the time of its
publication. Other documents may supersede this document. The latest status
of this document series is maintained at the W3C.
This document is a W3C Working Draft (WD), made available by the W3C Quality
Assurance (QA) Activity for discussion by W3C members and other interested
parties. For more information about the QA Activity, please see the QA Activity statement.
While keeping most of the principles behind the second published working draft, this third version has re-ordered the guidelines in a more logical way, and takes a more formal approach in the design of checkpoints, where every checkpoint has a set of test assertions. It integrates all the issues resolutions agreed during the QA WG Tokyo face-to-face meeting and the weeks following. A more detailed changelog is available below.
This document is accompanied by a QA
Framework: Specification Examples & Techniques document, which
illustrate the guidelines and checkpoints with case studies, and explain
how to satisfy the checkpoints.
The QA Working Group Patent
Disclosure page contains details on known patents related to this specification, in conformance with W3C policy
requirements.
Please send comments to www-qa@w3.org,
the publicly
archived list of the QA Interest
Group [QAIG]. Please note
that any mail sent to this list will be publicly archived
and available. Do not send information you would not want to see distributed,
such as private data.
Publication of this document does not imply endorsement by the W3C, its
membership or its staff. This is a draft document and may be updated,
replaced, or made obsolete by other documents at any time. It is
inappropriate to use W3C Working Drafts as reference material or to cite them
as other than "work in progress".
A list of current W3C Recommendations and other technical documents can be
found at http://www.w3.org/TR.
An appendix to this document [SPEC-CHECKLIST] presents all checkpoints in a tabular form, for
convenient reference.
The principal goal of this document is to define a framework to
assist the W3C Working Groups (WGs) in writing specifications that:
- are clearer,
- are more implementable,
- are better testable,
- facilitate the generation of test materials.
Within this Specifications Guidelines document, the term
"specifications" is specifically limited to W3C Technical Reports, even though these guidelines could be used along other documents.
This document describes what goes into the specification with
respect to conformance and conformance topics, followed by rules for
specification anatomy that should facilitate test development as well as
produce better, more testable specifications.
The set of checkpoints as a whole has been written in
anticipation that the checkpoints are being applied to new, in-development
specifications. It is not expected that existing specifications that pre-date
these guidelines will be able to satisfy all checkpoints as they are stated.
Many legacy specifications may indirectly comply with the spirit or intent of
some checkpoints, without actually satisfying all requirements in those
checkpoints.
The target audience of these specification guidelines
is:
- specification authors,
- those who review specifications during their development,
- implementers of specifications,
- those who use specifications to build test materials.
It is a design goal of these guidelines the WGs can apply them in a common-sense and
workable manner.
Good
specifications lead to better implementations and foster the development of
conformance test suites and tools. Conforming implementations lead to
interoperability.
The quality of the specification has direct impact on the quality of
implementations. Quality encompasses utility which refers to the
usefulness of the specification to the intended users and
objectivity which focuses on the whether the specification is
presented in an accurate, clear, complete, and unbiased manner.
Providing requirements and definitions about conformance topics, as well
as guidance in the structure and anatomy of specifications, will foster a
mutual understanding amongst developers of specifications, implementations,
and conformance test materials. Specifically, well-structured specifications
with clear and comprehensive conformance requirements:
- promote a common understanding of conformance and what is required to
claim conformance to a specification,
- facilitate consistent application of conformance within a
specification,
- facilitate consistent application of conformance across related
specifications,
- promote better interoperability and open interchange,
- encourage the use of applicable conformance test suites,
- promote uniformity in the development of conformance test suites,
- enhance test assertion identification and test traceability,
- promote automated test generation directly from the specifications,
This document defines a common framework for specifying conformance
requirements and definitions, and for representing the structure of the
document as schemata, both of which facilitate the generation of test
materials. The primary goal is to assist W3C Working Groups (WGs) by
providing guidelines and verifiable checkpoints for writing clearer, more
implementable, and better testable specifications (technical reports).
These guidelines were developed so that WGs can apply them in a common-sense and
workable manner. This document identifies the conformance requirements and
statements to be included or addressed in specifications as well as
addressing the anatomy of the specification. Conformance requirements are the
expressions that convey the criteria to be fulfilled in an implementation of
a specification. The conformance requirements are stated in a conformance
clause or statements within the specification. The anatomy of the
specification pertains to the method for writing the specification using
schemata. A specification represented by an XML grammar with sufficient
granularity of its information facilitates the generation of test materials
by providing the ability to point to, extract, query, manipulate and/or
automatically generate test materials. Given the symbiotic connection between
specification and test materials, this document also addresses the intermixed
quality practices of specification authoring and test material production and
maintenance within the W3C process.
This document is part of a family of QA Framework documents designed to
help the WGs improve all aspects of their quality practices. improve the quality of W3C specifications as well as their implementations by
solidifying and extending current quality practices within the W3C. The QA
Framework documents are:
The QA Framework documents are interrelated and complement each other. For
example, the anatomy of a specification is related to the type of test
materials that will be built, hence there is interrelationship between this
document and the Test Guidelines. The reader is strongly encouraged to be
familiar with the other documents in the family.
The Framework as a whole is intended for all Working Groups, as well as
developers of conformance materials for W3C specifications.
Not only are the
Working Groups the consumers of these guidelines, they are also key
contributors. The guidelines capture the experiences, good practices,
activities, and lessons learned of the Working Groups and present them in a
comprehensive, cohesive set of documents for all to use and benefit from. The
objective is to reuse what works rather than reinvent and to foster
consistency across the various Working Group quality activities and
deliverables.
This document does not preclude the need to apply the W3C Manual of
Style [STYLE-MAN] and to
conform to the Publication Rules [PUBRULES ] (member-only). It is intended
to complement those specifications.
The process for developing testable technical reports and specifications
is affected by QA activities beyond those that are explicitly provided in
this document. Specifically, the QA Framework documents are interrelated and
complement each other. For example, the anatomy of a specification is
dependent on the type of test materials that will be built - hence there is
interrelationship between this document and the Test Guidelines. Links
between applicable guidelines in this document and the other Framework
documents will be given.
The guidelines are intended for all Working Groups as well as developers
of conformance materials for W3C specifications. Not only are the Working
Groups the consumer of these guidelines they are also key contributors. The
guidelines capture the experiences, good practices, activities, and lessons
learned of the Working Groups and present them in a comprehensive, cohesive
set of documents for all to use and benefit from. The objective is to reuse
what works rather than reinvent and to foster consistency across the various
Working Group quality activities and deliverables.
Motivation for this guidelines document
The ultimate goal of a specification is to be implemented. In order to be
implemented, a specification needs to be written such that developers and
users can comprehend what is expected of them and build correct, robust,
interoperable software and content. Correct utilization of specifications
leads to portability and interoperability. In particular, it is easier to
implement clear specifications, where the possibility of misinterpretation
has been eliminated, safeguarding the quality of implementations. In
addition, if care is given to the specifications, interoperability between
W3C technologies is easier to track and assert.
Given that the W3C invests time and resources into producing
specifications that are eventually implemented, and especially given that
some of those specifications are interrelated, it makes sense to enhance and
streamline the specification authoring process. This should be done for three
main reasons:
- More straightforward specifications are easier to understand and
implement
- They foster the development of conformance materials
- It is easier to construct W3C-generic testing frameworks if both the
test framework and what is being tested, i.e. implementations and
specifications, follow generally accepted and implemented rules.
The W3C needs to ensure that the deliverables of its WGs are clear, implementable and sound
technical specifications with testable requirements and that can be used to
easily generate Quality Assurance materials (tests and suites). A
specification is testable if there exists some finite cost-effective process
with which a person or software can check that the requirement has been
met.
The benefits of producing clear, testable specifications include:
- Straightforward to assess and assert conformance
- Easy to generate tests and test suites
- Given that specification authoring is standardized, it will be
straightforward to test interdependencies between specifications (for
example it is easier to point to relevant parts of other specifications
with regard to technical details where specifications share common
features) as well as test interoperability between implementations of
different W3C specifications.
The benefits derived by writing granular specifications that provide
detailed control over the information in the specification, include
- Information extraction directly from the specification
- Generating a test harness directly from specifications
- Traceability
- Generating graphical representations of and interfaces to
specifications
- Efficient and effective test development
In particular, information from the specifications is easier to extract if
specification authoring involves a standardized set of specification schemata
where both technology and intended behavior is specified. Tests can be
generated directly from the specifications, where needed, to generate primers
for test suites. In this way, a fairly broad coverage of test cases can be
achieved in a straightforward way. An added bonus is that a graphical
representation of the specification can be generated in parallel to the
normative HTML version. Specification granularity allows for more concise
reporting when running test suites by pointing directly to the relevant part
of the specification. Specification granularity allows for generating tests
that can be validated against the specification itself, thus making it easier
in those cases where different interpretations of the normative text are
given.
Use of a formal (or formal-like) specification language may enable
'validation' of the specification as well as auto generation of tests or test
components.
Synchronizing writing specifications with building test materials provides
a feedback loop. Testing can help find ambiguities, inconsistencies, and
holes in a specification.
In particular
- Ambiguities and misinterpretations are more easily caught and can be
resolved earlier in the specification writing process
- Given the possibility to automatically generate primers for test
suites, coverage can be tracked fairly easily and therefore enhanced.
Corner cases are easy to identify and write tests for.
Interaction between WGs and other
bodies in specification authoring is related to test suite production and
maintenance. The reasons to develop specifications, test assertions, and test
materials together are:
- help to uncover inconsistencies, ambiguities, gaps, and non-testable
statements in the specification by developing the test assertions in
parallel with the specification.
- ensure consistency between the specification and assertions,
- allow test assertions to be reviewed and accepted by the specifications
developers and the public,
- provide a common set of assertions from which test developers can
develop test materials
- encourage the early development of conformance tests that can be used
by implementers during the development of their implementation,
- achieve confidence in the resulting test materials as a measure of
conformance.
Since this document is a member of a family of documents, the reader is
strongly encouraged to be familiar with the other documents in the family.
There is an interrelationship between the Guidelines in this document and the
Guidelines in the other Framework documents. In particular, Guidelines 1, 2, 3 and 5 in the QA Framework:
Operational Guidelines [QAF-OPS] are
especially relevant and interrelated to the Guidelines in this document.
This document describes what goes into the specification with respect to
conformance and conformance topics, as well as rules for specification
anatomy that should facilitate test development and produce better,
more testable specifications. It does not preclude the need to apply the
W3C Manual of
Style [STYLE-MAN] and to conform to the
Publication
Rules [PUBRULES] (member-only).
This document employs the WAI (Web Accessibility Initiative) model for
representing guidelines or general principles for the development of
conformance materials. See, for example, Web Content Accessibility Guidelines
1.0 [WCAG10]. Each guideline includes:
- the guideline number,
- the statement of the guideline,
- the rationale behind the guideline,
A list of checkpoint definitions.- a collection of one or more checkpoints.
The checkpoint definitions in each guideline define specification characteristics and requirements the processes and
operations needed to fulfill the purpose of that need to be implemented in order to accomplish the guideline.
Each checkpoint definition includes:
- the checkpoint number,
- the statement of the checkpoint (its "title"),
- the priority of the checkpoint,
- a statement of how to fulfill the checkpoint,
- optional informative notes, clarifying examples, and cross references
to related guidelines or checkpoints.
- a link to the corresponding section in Specification Examples &
Techniques.
Each checkpoint is intended to be specific enough so that someone can
implement the checkpoint as well as verify that the checkpoint has been
satisfied. A checkpoint will contain at least one, and may contain multiple
individual requirements , that use RFC2119 normative keywords. See the "Conformance"
chapter for further discussion of requirements and test assertions.
Caveat. The set of checkpoints as a whole has been written in anticipation
that the checkpoints are being applied to new, in-development specifications.
It is not expected that existing specifications that pre-date these
guidelines will be able to satisfy all checkpoints as they are stated. Many
legacy specifications may indirectly comply with the spirit or intent of some
checkpoints, without actually satisfying all requirements in those
checkpoints. It has been a design goal of this guidelines document, to phrase
checkpoint requirements and to set priorities so that well-written legacy
specifications that meet the most critical requirements may qualify for
conformance degree "A-conforming" (see "Conformance"
chapter.)
A separate appendix to this document [SPEC-CHECKLIST] presents all checkpoints in a tabular form, for
convenient reference. This is an Implementation Conformance Statement (ICS) pro-forma for this specification. (See GL12.)
The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY ", and "OPTIONAL" will be used as
defined in RFC 2119 [RFC2119]. When used with the normative RFC2119 meanings, they will be all upper case. Occurrences of these words in lower case comprise normal prose usage, with no normative implications.
Unusual terms in these framework documents are defined when first used.
This document contains a "Definitions" chapter.
Most Generally useful QA-specific terms will eventually be in the QA Glossary
[QA-GLOSSARY]. If terms are in the QA Glossary, their
definition herein will refer to that QA Glossary entry with a link. The definitions herein
may supplement or build on that generic definition with other information
that is useful or helpful in the specification guidelines context. They will
not contradict the generic definitions.
Satisfaction of the checkpoints in this guidelines specification are key
requirements to produce a high quality, testable standard that is a suitable
basis for successfully interoperable products. Some checkpoints are more
critical than others for producing a high
quality, testable standard that is a sound basis for successfully
interoperable products. Therefore each checkpoint is assigned a priority level
based on the checkpoint's impact on the quality of the specifications
produced by the Working Groups.
- [Priority 1]
- Critical/Essential. These checkpoints are considered to be basic requirements for
ensuring an acceptable level quality and testability in the
specification.
- [Priority 2]
- Important/desirable. Satisfying these checkpoints, in addition to the priority 1
checkpoints, should significantly improve the clarity, quality, and
testability, of the standard, as well as its suitability as a basis for
building quality test materials.
- [Priority 3]
- Useful/beneficial. Satisfying these checkpoints, on top of all the others, will further improve the quality, usability, and testability of
the specification.
is a
significant step toward ensuring the highest levels of quality and
testability of the specification.
The guidelines address two general themes: specifying conformance
requirements in the specification; and addressing the anatomy of the
specification.
Theme 1, Conformance content: general
requirements and definitions concerning conformance and related issues. It is
intended to contribute toward mutual understanding among developers of
specifications and conformance test suites and tools. It does not define
specific conformance requirements for any specific specification - this is
the responsibility of the WG
chartered to develop the specification. For the developers of specifications,
it helps them to develop conformance requirements and to create testable,
unambiguous specifications. A conformance clause:
- promotes a common understanding of conformance and what is required to
claim conformance to a specification
- facilitates consistent application of conformance within a
specification
- facilitates consistent application of conformance across related
specifications,
- promotes interoperability and open interchange,
- encourages the use of applicable conformance test suites,
- promotes uniformity in the development of conformance test suites
Theme 2, Anatomy: invest in writing granular specification with careful
modeling of the information conveyed. This allows for:
- detailed control over information extraction from the spec
- generating tests directly from the specs
- easy graphic interface to specification
Variability, complexity, and roadmap of guidelines
There are 15 guidelines that are presented in a sequence that runs
approximately from the general to the specific. The later (higher-numbered)
guidelines are likely to depend upon decisions made in accordance with
earlier guidelines.
The first four guide the establishment of strategic objectives and address
the overall motivation for the creation of the specification. The next two
bring the QA concerns into the plan. Guidelines 7 through 9 are about
additional specification tools to adjust the boundaries between conformant
and non-conformant implementations. The final six guidelines pertain to
particular documentation features.
There are 14 guidelines:
- Scope and use cases (often in Requirements Document)
- Specification categories and product classes
- Profiles (hardware, environment, etc.)
- Modules
- Levels
- Conformance policy
- Deprecation policy
- Discretionary items
- Extensibility
- Conformance clause
- Claims of conformance
- Proforma
- Document conventions
Granular grammar- Test assertions
The guidelines are of two general types:
- those that deal solely with the document features and conventions of
the specification — GL1 and GL10 - GL14;
- those that, in addition to documentation aspects, deal with how
specifications should establish and define the conformance policy for the
specification's technology, including ways in which the technology may be
subdivided for conformance purposes — GL2 - GL9.
It is necessary to clearly distinguish between the specification — the
W3C Technical Report — and the technology that it describes. For example, in
Guideline 4, profiling is a
method to partition the technology into groups, and profiles are technology
groups. Profiling and profiles of the technology may or may not lead to
division of the specification into multiple parts or units, concurrent or
subsequent. This document will strive to keep the distinction clear, even
though in common usage concepts such as profiles typically are used to refer
to both. [@@Ed note. This is not implemented completely in text yet.]
Each of the latter set of eight guidelines GL2 through GL9 addresses a way
in which the conformance policy of a specification might allow variation
amongst conforming implementations. For example, a specification might allow
implementations to choose between one of two well defined behaviors for a
given functionality, thus two conforming implementations might vary on that
aspect.
In dealing with Theme 1, considerable complexity is
introduced by a basic reality of diverse W3C specifications: multiple
dimensions of variability (DoV) can be accommodated in a specification. The
Working Group may determine that conformant products are allowed to vary in
one or more ways. Guidelines 2 through 9 cover the "dimensions of
variability" that a specification may permit. This document recognizes
the following dimensions of variability:
For this reason, these eight guidelines are collectively called the
"dimensions of variability (DoV)". The eight dimensions of variability
recognized by this document are:
The above are not necessarily all orthogonal to one another — some of the
possible associations and relationships are noted in the individual
guidelines.. There are
many possible associations, dependencies, and interrelationships. As a
general policy, these specification guidelines do not attempt to legislate
correct or proper relationships amongst the DoV. Rather, they try to clarify
the nature of each dimension, and require specification to make deliberate
and well documented choices. Some discussion of possible
interrelationships, including examples will be found in the Specification
Examples & Techniques.
The dimensions of variability comprise a tool used in this guidelines
document are one of the principal concepts in this guidelines document to help organize, classify and assess the conformance
characteristics of W3C specifications. The eight DoV get special attention
because, since they are at the core of the definition of a specification's
conformance policy, there is significant potential for negative
interoperability impacts if they are handled carelessly or without careful
deliberation.
As a general principle, variability complicates interoperability.. While variability complicates
interoperability, its In
theory, interoperability is best when there are numerous identical,
complete, correct implementations. However, in practice, the net effect of
conformance variability is not necessarily negative in all cases,
when compared to the alternatives — e.g., profiles, compared to a large
monolithic specification. For example profiles — subdivisions of the technology
targeted at specific applications communities — introduce variability
amongst implementations. Some will implement Profile ABC, some will
implement Profile XYZ, and the two might not intercommunicate well if ABC and
XYZ are fairly different. However, if ABC and XYZ are subsets of a large
monolithic specification — too large for many implementors to tackle in toto
-- and if they are well targeted at actual application sectors, then
subdivision by profiles may actually enhance interoperability.
Different sorts of variability have different
negative and positive impacts. The principal danger is "excessive" variability - variability
which goes beyond that needed for positive interoperability tradeoffs, and
which unnecessarily complicates the conformance landscape.In any case, Specification writers need to
carefully consider and justify any conformance variability allowed, do so by
reference to the project requirements and use cases, and explicitly document
the choices made.
When writing specifications it is critical to understand their primary
purpose and scope. Clearly defined scope helps to keep the specification
content focused and unambiguous.
If the specification describes content requirements (for example, [WCAG10], [UAAG10]), understanding of
their purpose is the key to defining the minimal sufficient set. If the
specification describes a protocol or Application Programmer Interface
(API) — examples
include XML Protocol, DOM --
there should be a clear understanding of the primary use cases. For the
purposes of this document, a use case is a specification mechanism or
technique that captures the ways a specification would be used, including the
set of interactions between the user and the specification as well as the
services, tasks, and functions the specification is required to perform. A
complete set of use cases specifies all the different ways to use the system
(specification).
Readers of the specification face similar difficulties to writers. To
understand what the document says, the reader needs to know the context of
the author, and the scenarios the author had in mind. In case of protocols
and APIs
specifications developers try to assess whether the specifications cover the
use cases the product needs to cover. Having no use cases described in the
specification invites misuse of the specification itself.
Checkpoints
To fulfill this checkpoint, a specification MUST define what scenarios are in scope and SHOULD identify out of scope scenarios.
Rationale: it helps both the writer and the reader to know what are the limits of what is specified in a normative document.
This is very basic but powerful requirement. The specification must
clearly define what scenarios are in scope and what are out of scope in order
to be interpreted, implemented, and tested correctly.
A User Scenario is an instance of a use case, representing a single path
through the use case. Thus, there may be a scenario for the main flow through
the use case and other scenarios for each possible variation of flow through
the use case (e.g., representing each option). Unless otherwise specified,
when included in a specification a user scenario is considered to be
informative. The specification should have an extensive list of the user
scenarios that the authors have in mind.Priorities may be assigned to user
scenarios, describing how important the particular scenario is for the
specification.
To fulfill this checkpoint, a specification MUST include or link to User Scenarios, SHOULD have an extensive list of the user
scenarios that the authors have in mind
Rationale: User scenarios help to assess what features
are missing and what features are superfluous in the specification.
To fulfill this checkpoint, a specification MUST include or link to at least one example and SHOULD provide an example for each section that public feedback has shown to be unclear or hard to understand.
Illustrate behaviors or requirements in the specification by short and
precise examples. The more numerous the examples, the better it is for the
specification's comprehensibility. Specifications should illustrate every
major feature by example, although the satisfaction of this checkpoint does
not impose any specific relationship between examples, on the one hand, and
features or requirements.
Whereas the previous checkpoint can be satisfied by a collection of
examples with any relationship to the requirements and behaviors of the
specification, this checkpoint requires that there be a mapping from each
test assertion in the specification to an example. The relationship of test
assertions to examples need not be one-to-one, however examples should be
short and precise, for clarity and comprehensibility.
A formal description is a concrete or abstract representation of an intended behavior in the specification.
To fulfill this checkpoint, a specification MUST provide an example for each identified formal description.
It is hard to understand the formal descriptions of content without
informative interpretations.
For instance, the recent complex specifications like XML Schema [XML-SCHEMA] and XML Protocol have shown the interest of having a "Primer" part or section to illustrate how to use the
specification. Such a section does not substitute for the numerous examples
needed for each requirement or behavior described in the specification, but
illustrates how the specification fulfills the User Scenarios.
Categorizing the specification provides a basis for classifying the
software that may be affected by the specification — and thus, provides the
answer to "what needs to conform?". To answer this question, it helps to look
at the nature of the specification and categorize it. Most specifications can
be classified into one of the following categories:
- foundation or abstract (e.g., Infoset),
- content/data (e.g., MathML, SVG),
- protocols (e.g., SOAP),
- processors (e.g., XSLT,
XML Query),
- APIs (e.g.,
DOM),
- notation/syntax (e.g., XPath),
- set of events (e.g., one part of XForms)
- rules for deriving profiles (e.g., part of SMIL)
The categories indicate what the specification describes. One
specification could potentially fall into more than one category.
[Ed note. A survey of W3C recommendations according to this
categorization scheme is being worked on within QAWG. It is planned
that it will be linked from QA Framework: Specification Examples
& Techniques [SPEC-EXTECH] when that
document is published in
the near future.]
From this categorization of specifications, the WG can identify the class of products that
are affected by the specification. Classes of products can be generalized as
either or producers or consumers, or as content itself. Identifying which are
producers and consumers is clear for a protocol-type specification, the two
parties to the dialog are the targets. For a processor-type specification,
the processor is the consumer of an XML vocabulary defined in the
specification. For content-type specifications, there may be one or more
consumers that take the content and 'play' it in some way.
The following is a non-exhaustive list of classes of products for W3C
specifications.
- content (of type, meaning, and format as defined in the
specification)
- producer of content (may be divided into initiators and modifiers)
- player (read-only consumer, conveys content in non- XML way)
- consumer in a one-way pipeline
- responding agent (e.g., server) of API (consumer and
producer)
- processor (consumer of its vocabulary/instructions)
- module that hosts the processor
- producer of instructions/commands to processor
- profile derived from the specification's Rules for Profiles
One specification could define more than one player. For example, MathML
could address the behavior of display of math notation and also a consumer
that parses the MathML as a formula and uses it for mathematical
processing.
The conformance clause identifies the "class of products" (i.e., object of
the claim) that is the target of the specification. In addition to
identifying what conforms (i.e., class of products), it describes how
conformance can be met. This would be a description of the conformance
requirements, conditions and/or criteria for each class of product.
Checkpoints
To fulfill this checkpoint, a specification:
- MUST list the classes of product it addresses
- SHOULD use the above enumerated classes names when they match those of the specification
For those product classes which match one of the above enumerated classes, use the above
terminology to describe the class. This requirement is not applicable for
specifications which pre-date these Specification Guidelines.- MUST define and describe any product class that does not match the enumerated set
If the specification addresses a product class that does not match the
enumerated set, then the specification MUST define and describe the class.
Example. Within the SMIL 2.0 Language
Profile ([SMIL20], chapter 13), there are 2
classes of products: documents and basic user agents. Within Mathematical Markup Language (MathML)
2.0 [MATHML20] there are output-compliant,
authoring tools and input-compliant, rendering/reading tools.
Example. Schema Part 1 could be said to define an abstract notion of
"schema validity" but this checkpoint can only be satisfied if the
Recommendation says explicitly whether it is setting expectations of an
XML parser or of a
"schema validator" that could be stand-alone. Schema Part 2 defines data
types, so it is a specification of type 2 above — content/data — and it is
used as a foundation by other specifications (e.g., path 2.0) as well as
being part of the schema validator and hence parser requirements. The
specification could define the behavior of a data-input tool that rejects
data not fitting the schema, but it probably would not because the tool would
be expected to use a parser module to validate the data. To satisfy this
checkpoint, the Schema Part 2 specification has to make clear whether it is
to be taken as an independent specification of a parser (that
produces data from arbitrary strings) or a foundation to be used by
other specifications.
Specifications that are used as components of other specifications and
rely on these other specifications to define conformance MUST also indicate that conformance criteria for independent implementations are not defined within the specification.
Example. XPath (XML Path
Language 1.0, [XPATH10]) relies on
specifications that use XPath — such as XPointer (XML Pointer
Language, [XPOINTER]) and XSLT (XSL Transformations 1.0, [XSLT10]) — to specify criteria for conformance of
implementations of XPath.
The conformance requirements indicate the conditions to be satisfied in
order to claim conformance. In addition to specifying the requirements for
claiming conformance, it may be appropriate to specify that which is not a
requirement. It is likely that these conformance definitions will reference
normative text within the specification or in other related
specifications.
To fulfill this checkpoint, a specification MUST define the conformance requirements for each class of product.
To fulfill this checkpoint, a specification MUST describe the minimum set of elements,
attributes, etc., that are required to claim conformance. If there are no
minimum support requirements — i.e., the minimal support requirement
includes all of the functionality of the specification — it MUST explicitly state
that.
Rationale: this is helpful in providing the reader a full understanding of the conformance requirements, especially when some of the classes of products
have minimal requirements whereas others do not.
If there are distinct minimal requirements, then — implicitly or
de-facto, if not explicitly — the specification has levels (minimal = level
1) or modules (minimal = core module or core module set). If the
specification has profiles, then any specification-wide, cross-profile
distinct minimal requirements would represent something that all the profiles
have in common. This effectively is a "rule for profiles", i.e., a
conformance constraint on profiles that are valid by some definition in the
specification.
To fulfill this checkpoint, a specification MUST identify in the Introductory section which of the
types of object are specified in the
document as a whole.
Rationale: doing so helps keep the scope of the specification in
focus, both for the reader, and for the author(s) who must define the classes of product and their conformance criteria.
Some specifications define more than one of the enumerated object types.
XForms is an example. It defines: Content, via an XML vocabulary; Content, via
named datatypes;
Syntax, in the form of a set of functions to
supplement the XPath core set; behavior of a processor;
behavior of a user
agent; a set of
events.
A look at various W3C Technical Reports shows that the term "conformance"
is often qualified, resulting in more than one type of conformance. It is
important to convey an understanding of what is meant by conformance and
where the products of a class are allowed to have more, less, or different functionality
than defined in the specificationfrom one another. If the specification defines behavior for
more than one class of product, there may be a separate conformance policy for each class. Often, the specification will allow discretionary choices,
such as the choice of one or more natural languages for verbal content and
messagesdate-time formats, but require a conforming product to make a choice only within the
allowable range. (See Guideline 8 for
more discussion.)
Sometimes a product developer can choose to implement certain modules.
There may be per-module conformance requirements that apply if and only if
the developer chooses to implement a particular module.
Sometimes a product developer can choose to implement extensions. There
may be conformance requirements for non-interference of extensions. (See
Guideline 9 for more discussion.)
Where all products of a class must be substantially alike, it should be
clear that a "strict conformance" policy is in effect for that product class.
Strict conformance is defined as conformance of an implementation that employs only the
requirements and/or functionality defined in the specification and no more
(e.g., no extensions to the specification are implemented). No discretion is granted to implementers, and any
requirements for handling deprecated features must be followed.
Sometimes a product developer can choose to implement extensions. There
may be conformance requirements for non-interference of extensions. (See Guideline 9 for more discussion.)
Overall, the intent of the WG
should be clear. In particular, a reader intending to implement a product in
one of the product classes addressed by the specification should know what
the WG wants for interoperability
among products in the class. The developer should understand what forms, if
any, of "product differentiation" are allowed among conformant products. The
specification may need to explain how the rules apply and possibly provide
examples.
Guideline 10, "conformance clause" is related to this guideline. This
Guideline 3 focuses on the establishment and scope of definition of a
conformance policy, while Guideline 10 focuses on where and how to document
it. That is, the verification of these checkpoints will require looking at
the Conformance Clause.
Exercise caution - the conformance policy is one of the dimensions of variability, and there
are several opportunities for variability within it. Excessive variability
fragments and confuses the marketplace, which inhibits interoperability.
Furthermore, dividing the conformance policy of a single specification in two
or more ways creates complexity — complexity generally retards
interoperability, while simplicity generally facilitates it.
Checkpoints
To fulfill this checkpoint, a specification MUST include a normative section detailing any universal requirements for minimum functionality. It is not applicable if there isn't any universal requirements.
Rationale: the reader must be able to recognize any minimum that applies to all conforming products of each class. The test suite can have a core
of universal test cases.
If levels are used (see Guideline 6), the lowest level
may represent the minimum set of requirements. If profiles are used (see Guideline 4), there may be
different minima for each profile. If modules are used (see Guideline 5), there may
be different minima for each module. Furthermore, a module may itself be a
minimum (i.e., required) for a particular class of product.
To fulfill this checkpoint, a specification MUST state in its conformance section if the conformance requirements are strict or identify the kinds
of variability that are permitted..
Rationale: the reader must be able to recognize when a policy of "strict conformance"
applies. As defined above, this implies
that all conformant products of a class behave essentially the same way.
Strict conformance can apply separately to each class of product addressed
by the specification. If
profiles are used, each profile may have its own conformance boundaries. If
modules are used, each module may have its own conformance boundaries. Some profiles or modules may have a strict
conformance policy while others do not.
To full this checkpoint, a specification MUST state in its conformance
section all facets of the requirements where the required features
represent the maximum allowable capabilities.distinguish any requirements from product-specific extra features.
Rationale: The reader must be able to recognize conformance requirements as distinct
from allowable extra functionalityWhen a strict conformance policy applies, the maximum set of
features is the same as the minimum. When strict conformance does not
apply, implementations may be allowed to exceed the specified capabilities
in ways other than having extensions. (Example: a graphical capability may
be specified with a required resolution or a set of resolution levels that
must be supported. The specification may wish to require that
implementations not create images of higher resolution due to concerns
about excessive size.) The specification should identify the facets in
which an implementation may add more features, if there is a history of
expanding features for those facets.
If profiles are used (see Guideline 4), make it clear state
whether extra capabilities of the platform may be exploited. If modules are
used (see Guideline 5), there
may be different provisions for extra features applying to each. If
levels are used (see Guideline 6), state whether the highest level may be
exceeded with additional features or functionality. If
deprecation applies (see Guideline 7), make it
clear whether support of the obsolete features is optional, part of a level,
or required. If levels are used (see Guideline 6), make it clear whether
the highest level may be exceeded with additional features or functionality.
If discretionary choices are allowed (see Guideline 8), make it clear if more than one
may be implemented, when it is technically possible to do so.
To fulfill this checkpoint, a specification MUST either exclusively use conformance terms as defined in this document or define any other conformance terms used in it and reference them from the conformance clause.
Rationale: it is necessary to define terms that govern application of the conformance
provisions. Ideally, all terms are from QA documents and other existing
literature and need only be cited. If special terms are constructed, such as
to combine modules and levels or modules and discretionary choices, they need to be defined in the specification.
Dividing the technology that a specification describes into functional
groupings can facilitate its implementation by enabling a developer to build
to portions of the technology rather than implementing it all. Some of the
dimensions of variability, but not all, can be used to divide the technology:
product classes, profiles, modules, and (to some extent) levels divide the
technology, while extensibility separates specified behavior from other
product features.
A profile is a subset of the technology that supports a particular functional objective or a subset of a set of technologies defining. Profiles can also be used to group the technologies of
a set of standards and define how they are required to operate together
(e.g., XHTML plus MathML plus SVG).
Profiles can be based on
hardware considerations associated with target product classes — for
example, SVG Tiny is
aimed at mobile phones — or they may be driven by other functional requirements of their target constituencies — for example, a graphical
profile tailored for technical illustrations in aircraft maintenance
manuals.
Modules are independent divisions or functional groupings of the
technology, that can be implemented independently (e.g., audio vs. video
module). See Guideline 5 for the
full discussion of the topic. Within W3C specifications, a very common way to
define profiles is to modularize the technology, and gather together several
modules to define a profile.
Levels are used to group functionality into nested subsets. See Guideline 6 for a full discussion of
the topic. A profile can require a particular level in its entirety. A
profile can also be defined as a subset of a level or levels. Hierarchy is an
essential attribute of levels. While it is not an essential attribute of
profiles, nevertheless profiles can be hierarchical in the sense that Profile
B can be defined as all of Profile A plus additional capabilities.
The use of profiles to divide the technology is described in the
specification, and may or may not be reflected and paralleled by the
structure and organization of the specification.
Specifications may define individual profiles, or may define rules for
profiles, or both. An individual profile defines the requirements for classes
of products that conform to that profile. Rules for profiles define validity
criteria for profiles themselves — i.e., if others (users, applications, or
other standards) define their own profiles of the standard, then rules for
profiles define the constraints that those profiles must satisfy in order to
be considered valid profiles of the specification.
For example, XHTML Modularization ([XHTML-MOD], section 3) and Synchronized
Multimedia Integration Language (SMIL 2.0), [SMIL20] specifications both define rules for profiles --
what constraints must a profile meet in order to be classified as a "Host
Language Profile" or an "Integration Set Profile." SMIL further defines some
specific profiles, using the modularization. Separate recommendations --
XHTML Basic [XHTML-BASIC] and
XHTML 1.1 [XHTML11] — define specific
profiles based on the XHTML modularization.
The SMIL Recommendations (e.g., [SMIL20]) illustrate
several of these concepts at once. Modularization is an approach in which
markup functionality is specified as a set of modules that contain
semantically-related XML elements, attributes and
attribute values. Profiling is a method for defining subsets of technology by
identifying the functionality, parameters, options, and/or implementation
requirements necessary to satisfy the requirements of a particular community
of users. In SMIL, it is the creation of an XML-based language through
combining these modules that provides the functionality required by a
particular application community. Based on a modularization framework, SMIL
defines rules for profiles — e.g., "SMIL
Host Language Conformance" (section 2.4.1, [SMIL20]) — as well as defining some specific profiles --
e.g., the SMIL
Language Profile and the SMIL Basic Profile
(sections 13 and 14, [SMIL20]).
It should noted that profiling is not applicable for all W3C
Recommendations, for example Namespaces in
XML [XML-NAMES].
Exercise caution - profiles represent one of the dimensions of variability. Excessive
variability fragments and confuses the marketplace, which inhibits
interoperability. Furthermore, dividing the conformance policy of a single
specification in two or more ways (i.e., by two or more dimensions of
variability) creates complexity — complexity generally retards
interoperability, while simplicity generally facilitates it.
Checkpoints
It is possible for a specification to define and use one or more of
profiles, modules, functional levels, or none of these. If profiles are
defined and supported in the specification, explicitly say so. Furthermore,
the specification MUST explain why profiles are necessary, by reference to
use cases and/or project requirements.
If profiles are not used, see the disclaimer requirements of Checkpoint 10.5.
To fulfill this checkpoint, a specification MUST have a link in the table of contents to informations about the use of profiles. It is not applicable on specification that do not use profiles.
The reader should be able to easily identify and locate information about
profiles. A link from the table of contents (TOC) provides this ability. The
form of TOC linkage can vary,
depending on the style of the specification — some have only a high-level
TOC, some have a detailed
TOC, and some have both.This
checkpoint could be satisfied by TOC links to specific profile-related
text from a detailed TOC. For a
high-level TOC, it could be
satisfied by a link to a conformance clause section that either contains or
points to profile information. It could be satisfied by both of the two
previous when both types of TOC
are present.
To fulfill this checkpoint, a specification
- MUST state whether conformance of each class of product
in the specification is only defined within the context of profiles, or
whether there can be conforming products outside of the
bounds of profiles.
- MUST describe additional conditions associated with a particular profile or collection of profiles for each class of product
It is not applicable if profiles are not used.
For example, is content required to conform to one of the profiles, or is there a concept of conformance of content independent of conformance to one of the
profiles? Is a producer (of content) conforming if it generates content that
is otherwise valid but does not conform to a profile?
An example of additional conditions on profiles would be to require that only one profile can be implemented at a time.
removed because integrated directly in the 2 other TA
- A specification must address this checkpoint's requirements
individually for each class of product defined in the specification.
To fulfill this checkpoint, a specification MUST define for each profile the minimal required features/support for each class of product. It is not applicable if profiles are not used.
Rationale: because a profile places explicit requirements on each class of product that have specific and often limited operating environments these requirements must be defined for each class of product that is affected.
removed because redundant with following example For example, for a user-agent product class, a profile must define the
minimal language support requirements for that target's user agents. This may be done by requiring specific modules (in a modularized specification), levels (if the specification is level-structured), or specific lists elements and attributes.
To illustrate, SMIL 2.0 [SMIL20] has a
SMIL 2.0 Language Profile for user agents but also provides a SMIL 2.0 Basic
Profile for wireless and embedded devices. The SMIL 2.0 Language Profile
requires that a user agent implement the BasicAnimation module but not the
SplineAnimation Module. The SMIL 2.0 Basic Profile on the other hand does not
require implementation of any of the Animation modules.
To fulfill this checkpoint, a specification MUST identify all the relations and interactions between profiles and the other dimensions of variability. It is not applicable if profiles are not used.
Dependency or interrelationship between profiles and modules is common --
XHTML [XHTML-MOD], SMIL [SMIL20], SVG 1.1 [SVG11]. Less often,
deprecated features, levels, discretionary choices, or extensions could
depend on profiles.
If it is anticipated that groups may define new
profiles in the future, and if the specification allows the creation of derived profiles, to fulfill this checkpoint a specification MUST provide requirements for derived profiles and these requirements MUST be testable. It is not applicable if profiles are not used.
It is RECOMMENDED that requirements for derived profiles impose at least
these two rules on derived profiles: derived profiles SHOULD be specified in
a way that meets all the pertinent checkpoints of this document (QA
Framework: Specification Guidelines); and, derived profiles SHOULD NOT
contradict pre-defined profiles, if there are any in the base specification.
Rationale: well-designed rules for profiles will facilitate that derived profiles are well-specified, and testability will enable an independent tester to verify
conformance of a derived profile to the rules.
Dividing the technology that a specification describes into functional
groupings can facilitate its implementation by enabling a developer to build
to portions of the technology rather than implementing it all. Some of the
dimensions of variability, but not all, can be used to divide the technology:
product classes, profiles, modules, and (to some extent) functional levels
divide the technology, while extensibility separates specified behavior from
other product features.
Modules are non-hierarchical, discrete divisions or functional groupings of the technology.
For example, SMIL 2.0 [SMIL20]
defines a module as follows:
A module is a collection of semantically-related XML elements, attributes, and
attribute values that represents a unit of functionality. Modules are
defined in coherent sets.
Modules generally can be implemented independently of one another — e.g.,
audio vs. video module. That notwithstanding, it is possible for one module's
definition (and therefore implementation) to have explicit dependency upon
another module. It is not only possible, but common to implement multiple
modules.
Modules and profiles. Within W3C, a common relationship between modules
and profiles is to build profiles by assembling modules in different
collections. This approach is used in both XHTML and SMIL 2.0, and in fact is
the driving motivation behind their modularization. In both, it is required
that modules be atomic when included in profile definitions — profiles
cannot subset modules. Conversely, there are examples where profiles subset
(some) modules, and are defined by a collection of modules and pieces of
modules (e.g., the Tiny and Basic profiles of the SVG Mobile [SVG-MOBILE] subdivide some of the modules of SVG 1.1
[SVG11]).
Atomicity of
modules. Several W3C specifications with both modules and profiles have
the requirement that modules must be atomic — modules may not be subdivided
in profiles. Such a constraint requires:
- a clear understanding of the granularity of the technology;
- comprehension of the requirements of present and anticipated
profiles;
- a carefully designed modularization that integrates these two.
This is a recommended design constraint for specifications that modularize
their technologies for the purpose of building profiles, because it limits
the variability among derived profiles. Examples: The rules for profiles in
XHTML and SMIL require
atomicity of modules, in order that the resulting profiles qualify for
classifications such as "Host Language Conformant" or "Integration Set
Conformant". See Guideline 4
for full discussion of profiles.
Modules and levels. Levels are specifically designed to represent
hierarchical steps, for example DOM level 1, DOM level 2, and DOM
level 3. See Guideline 6 for full
discussion of levels. Levels in W3C specifications most commonly reflect
progressive historical development of the specification, rather than
all-at-once design and standardization. In current W3C practice, nested
profiles have often been used in cases of one-time definition of functional
levels within a specification. The nested Tiny, Basic, Full profiles of SVG
Mobile [SVG-MOBILE] are an example that could, in
principle, have been defined as three levels.
The relationship of modules and levels is less obvious than the
relationship of modules and profiles. In principle, at least, two
relationships can be envisioned:
- In principle, levels could divide modules. For example, level 1 and
level 2 could be defined as different resolution/precision levels within
audio and video modules. Note that this modules-levels relationship would
likely result from all-at-once design of the levels at the same time as
the modules. I.e., it would not likely happen with levels that result
from historical enrichment. In such cases — e.g., see XHTML's discussion
of evolution of modules — an "enriched" module is given a different name
and effectively designated as a new, different module. There are no clear
examples of this potential relationship yet in W3C specifications.
- In principle, levels could contain modules. This could result from
historical evolution of a modularized standard — during level-2
standardizations, some new modules are defined, which when added to the
modules of level 1 would define level 2.
[@@Issue about
goodness criteria, from 7/24
telecon. I.e., levels could divide modules or whole modules could be
grouped into levels during progressive (historical) development of the
standard. Is one good and the other bad? Is either one to be encouraged or
discouraged?]
Exercise caution - modules represent one of the dimensions of variability. Excessive
variability fragments and confuses the marketplace, which inhibits
interoperability. Furthermore, dividing the conformance policy of a single
specification in two or more ways creates complexity — complexity generally
retards interoperability, while simplicity generally facilitates it.
Checkpoints
It is possible for a specification to define and use one or more of
profiles, modules, functional levels, or none of these. If modules are
defined and supported in the specification, explicitly document it.
Furthermore, the specification must MUST explain why modules are necessary, by
reference to use cases and/or project requirements.
If modules are not used, see the disclaimer requirements of Checkpoint 10.5.
To fulfill this checkpoint, a specification MUST have a link in the table of contents to informations about the use of modules. It is not applicable on specification that do not use modules.
Rationale: the reader should be able to easily identify and locate modules
information. A link from the table of contents (TOC) provides this ability.
The form of TOC linkage can
vary, depending on the style of the specification — some have only a
high-level TOC, some have a
detailed TOC, and some have
both. This checkpoint could be satisfied by TOC links to specific modules-related
text from a detailed TOC. For a
high-level TOC, it could be
satisfied by a link to a conformance clause section that either contains or
points to modules information. It could be satisfied by both of the two
previous when both types of TOC
are present.
If there are additional conditions or constraints associated with modules, To fulfill this checkpoint, a specification MUST
document any mandatory conditions or constraints on their usage. Such conditions include,
- atomicity of modules
- any mandatory module(s);
- any modules that are optional
- dependencies among modules:
- modules that require and build on functionally related modules;
- modules that require modules from other functional areas;
- constraints against combined occurrence of particular pairs of
modules;
- any other — there MAY be conditions and constraints other than just
enumerated, and they MUST be described.
It is not applicable if modules are not used.
To fulfill this checkpoint, a specification MUST specify any relationships and interaction with other dimensions of variability. It is not applicable if modules are not used.
Rationale: often there is dependency or interrelationship among modules, on the one hand, and profiles or discretionary choices on the other. Modules may have
levels This is wrong, CSS3 modules have levels (although no such examples are known among W3C standards), or
deprecated features. Extensions could be defined based on modules.
[@@Issue about goodness
criteria, from 7/24
telecon. I.e., levels could divide modules or whole modules could be
grouped into levels during progressive (historical) development of the
standard. Is one good and the other bad? Is either one to be discouraged?]
Dividing the technology that a specification describes into functional
groupings can facilitate its implementation by enabling a developer to build
to portions of the technology rather than implementing it all. Some of the
dimensions of variability, but not all, can be used to divide the technology:
product classes, profiles, modules, and (to some extent) functional levels
divide the technology, while extensibility separates specified behavior from
other product features.
Functional levels — or in common usage, simply "levels" — are used to group functionality into nested subsets, ranging from minimal or core
functionality to full or complete functionally. Level 1 is the minimum or
core of the technology. Level 2 includes all of level 1 plus additional
functionality. This nesting continues until level n, which consists of the
entire technology.
[@@Issue: Scope
of minimality of levels. Levels represent the minimal or core requirement
within the levels DoV. Do
they also represent a minimal or core requirement in the 3- DoV subspace spanned by the
profiles-modules-levels DoVs?]
Levels may result from progressive historical development and enrichment
of the technology in a series of specifications, as in the case of CSS and DOM. Levels could also be defined explicitly in a single edition of the specification, including in the first
edition, but no examples of this are found in W3C specifications. Rather, it is
more common in current W3C practice to use profiles to accomplish this. For
example, SVG Mobile [SVG-MOBILE] defines three
nested profiles — Tiny, Basic, Full — which are each targeted at a specific
graphics hardware community (mobile phone, hand-held computer, desktop
computer).
See Guideline 4 for full
discussion of profiles, including comments on possible profiles-levels
relationships. See Guideline 6
for a full discussion of modules, including possible modules-levels
relationships.
Exercise caution - levels represent one of the dimensions of variability. Excessive
variability fragments and confuses the marketplace, which inhibits
interoperability. Furthermore, dividing the conformance policy of a single
specification in two or more ways creates complexity — complexity generally
retards interoperability, while simplicity generally facilitates it.
Checkpoints
It is possible for a specification to define and use one or more of
profiles, modules, functional levels, or none of these. If levels are defined
and supported in the specification, explicitly say so. Furthermore, the
specification MUST explain why levels are necessary, by reference to use
cases and/or project requirements.
If levels are not used, see the disclaimer requirements of Checkpoint 10.5.
A specification may come to have levels in a number of ways:
- levels may be defined explicitly in a single (first) edition of the
specification, as a way to divide the technology (e.g., for conformance
policy purposes). There are no W3C examples of this.
- or, levels may be planned in the initial edition of the specification
(which defines level 1), as a mechanism associated with anticipated
enrichment of the technology in future editions of the specification.
DOM is an example.
- or, levels may be unanticipated initially, but may be decided and
described in later editions of the specification as a means to handle
evolving requirements additions to the technology. CSS development is an
example.
In all cases, to satisfy this checkpoint, a specification must address the
use of levels.
To fulfill this checkpoint, a specification MUST have a link in the table of contents to informations about the use of levels. It is not applicable if the specification doesn't use levels.
Rationale: the reader must be able to easily identify and locate levels information. A link from the table of contents (TOC) provides this ability.
The form of
TOC linkage can vary, depending
on the style of the specification — some have only a high-level TOC, some have a detailed TOC, and some have both. This checkpoint
could be satisfied by TOC links
to specific levels-related text from a detailed TOC. For a high-level TOC, it could be satisfied by a link to a
conformance clause section that either contains or points to levels
information. It could be satisfied by both of the two previous when both
types of TOC are present.
To fulfill this checkpoint, a specification MUST specify any relationships and interaction with other dimensions of variability. It is not applicable if levels are not used.
A deprecated feature is a feature
whose use is discouraged because it has been outdated by newer constructs or
is no longer viable.
After the initial publication of a specification, specification developers
may consider the deprecation of a feature (e.g., function argument, element
or attribute) defined in the specification. Deprecated features may become obsolete and no longer
defined in future versions of the specification. Deprecation of a feature may
warn implementers that the feature was a bad idea and it may be withdrawn in
the future. Specification developers need to consider the effect of
deprecation on all the classes of products that implement the specification
(e.g., authoring tools, user agents) as well as the conformance consequences
on each class of product. For the purpose of backward compatibility, it may
be necessary to specify different requirements for the support of deprecated
features for each class of product. For example, authoring tools (producers)
would not use the feature, but user agents (consumers) would continue to
support it.
Checkpoints
To fulfill this checkpoint, a specification MUST identify in a normative section and clearly indicate each deprecated feature. It is not applicable if there is no deprecated feature.
To fulfill this checkpoint, a specification MUST specify the degree of support required for each deprecated feature for each product class and the conformance consequences of the deprecation. It is not applicable if there is no deprecated features.
For example, a deprecated-features
section of MathML 2.0 ([MATHML20], section
7.2.1.2) describes, about deprecated MathML 1.x features, that
MathML-output-compliant authoring tools may not generate MathML markup
containing deprecated features; whereas MathML-input-compliant
rendering/reading tools must support deprecated features.
To fulfill this checkpoint, a specification MUST document each deprecated features with a rationale for deprecation. It is not applicable if there is no deprecated features.
Rationale: providing the rationale for deprecating a feature helps implementers and users to understand the motivation for the deprecation, the impact and
consequences on current and future implementations, and perhaps insight into
its eventual disappearance from the specification.
@@@ This probably only applies to "producers", not to "consumers". Is this OK? What if a spec only defines consumers and not producers
To fulfill this checkpoint, a specification MUST provide an example for each deprecated feature showing how to avoid using it. It is not applicable if there is no deprecated features.
Rationale: examples are helpful in providing alternatives or better ways to get the same results. By showing what can be done in place of the deprecated feature
will help to get implementers to discontinue use of the deprecated
feature.
To fulfill this checkpoint, a specification MUST have a link in the table of contents to informations about deprecated features. It is not applicable if there is no deprecated features.
Rationale: the reader must be able to easily identify and locate information about
deprecated features. A link from the table of contents (TOC) provides this
ability.
The form of TOC linkage
can vary, depending on the style of the specification — some have only a
high-level TOC, some have a
detailed TOC, and some have
both. This checkpoint could be satisfied by TOC links to specific deprecation-related
text from a detailed TOC. For a
high-level TOC, it could be
satisfied by a link to a conformance clause section that either contains or
points to deprecation information. It could be satisfied by both of the two
previous when both types of TOC
are present. In the case that there are numerous deprecated features,
consider a link to a table or list, which links to the individual locations
in the text.
Discretionary items are defined as
deliberate and explicit grants of discretion by the specification, to the
implementations, that describe or allow optionality of behavior,
functionality, parameter values, error handling, etc.
Discretionary items are often made available in specifications, to give
implementers of the technology the opportunity to decide from alternatives
when building applications and tools. Discretionary items may
be considered necessary because of environmental conditions (e.g., hardware
limitations or software configuration, or external systems), locality (e.g.,
time zone or language), optional choices providing flexibility of
implementation, dependence on other specifications, etc.
Discretionary items come in three basic variants:
- discretionary choices
- a value or behavior may be chosen from a
well-defined enumerated set of two or more possibilities;
- optional features
- a well-defined feature may be supported or not (if
supported, then the requirements are clear and unambiguous)
- implementation dependent values (or features)
- it is open ended and
undefined, what set of values an element or attribute may have, or the
behaviors of a product that implements a feature, etc
Deleted because mostly redundant with the definition above. One type of discretionary item is implementation dependent values.
Implementation dependent values are used when it is not desired or not
possible to define the behavior or values of a function. Implementation
dependent means that an implementation may determine the effect, rather than
using an effect mandated by the specification. Details in a specification may
deliberately be omitted (i.e., not specified), so as to provide freedom to
adapt implementations to different environments and different
requirements.
Exercise caution - discretionary behaviors represent one of the dimensions of variability. Excessive
variability fragments and confuses the marketplace, which inhibits
interoperability. Furthermore, dividing the conformance policy of a single
specification in two or more ways creates complexity — complexity generally
retards interoperability, while simplicity generally facilitates it.
Implementation-dependent values is a form of discretionary behaviors which
can have particularly harmful interoperability impacts — it is not a
recommended practice.
[@@Issue: add a
checkpoint? — "if impl dependent is allowed, document how it affects
interoperability of implementations."]
Checkpoints
To fulfill this checkpoint, a specification MUST indicate the rationale for the discretionary items by providing a reference or link to its use cases and/or project requirements and SHOULD identify by labeling all discretionary items. It is not applicable for specifications that don't have discretionary items.
Doing this helps readers, implementers and testers to find these discretionary items and understand the need for them.
If there are no discretionary items in the specification, see the
disclaimer requirements of Checkpoint 10.5.
To fulfill this checkpoint, a specification MUST describe any permitted variations or constraints for how the implementation dependency is realized by implementations.
Examples of permitted variations or constraints to be addressed include:
- implementation dependent ranges, data, minimum or maximum values,
- environmental resources (e.g., memory or disk limitations),
- environmental values (i.e., language and local settings).
Specifications may describe several different ways to accomplish its
operation (e.g., a choice of file formats, protocols, or encodings). In such
a case, enumerate the approaches and specify if there are limitations on the
number of approaches or combination of approaches that can be implemented.
Some possible ways to define conformance when allowing alternative approaches
include mandating that an implementation:
- implement only one approach,
- implement every approach,
- be allowed to implement none of the approaches.
Note that if the specification does not include the different approaches,
this becomes an implementation detail.
To fulfill this checkpoint, a specification MUST indicate whether zero, exactly one, or a multiple of choices/options are allowed to be implemented. It is not applicable for specifications that don't use discretionary items or for implementation dependent values among them.
Examples of constraints include mandating that an implementation implement only one choice, implement every choice, or be allowed to implement none of the choices.
To fulfill this checkpoint, the specification MUST state that given identical conditions, the effect of a discretionary choice is consistent within a single implementation.
Rationale. Users have an expectation of what to expect and should be able to count on getting the same results under the same conditions with a given implementation.
The effect of each individual discretionary item should be consistent
within a single implementation. For example, a browser's rendering of a
XSL-FO (XSL Formatting Object) should be the same for every invocation
regardless of the document instance.
To fulfill this checkpoint, a specification MUST have a link in the table of contents to information about the use of discretionary items. It is not applicable on specifications that do not use discretionary items.
The reader must be able to easily identify and locate information about
discretionary items. A link from the table of contents (TOC) provides this
ability.
The form of TOC linkage
can vary, depending on the style of the specification — some have only a
high-level TOC, some have a
detailed TOC, and some have
both. This checkpoint could be satisfied by TOC links to specific discretionary items
text from a detailed TOC. For a
high-level TOC, it could be
satisfied by a link to a conformance clause section that either contains or
points to discretionary-items information. It could be satisfied by both of
the two previous when both types of TOC are present. In the case that there
are numerous discretionary features, consider a link to a table or list,
which links to the individual locations in the text.
An extension to a specification is a mechanism to incorporate
functionality beyond what is defined in the specification.
Allowing
extensions affects how conformance is defined as well as what conformance
claims can be made. Exercise caution in determining the extent to which
extensions are allowed or not allowed. Since extensions can seriously
compromise interoperability, specification writers should carefully consider
whether extensions should be allowed.
Extensions may be private (often vendor specific) or may be public (a full
description of the extension is public). Private extensions are usually truly
private, i.e., valid for a specific implementation or are only known by prior
agreement between implementations. Public extensions are extensions in which
the syntax, semantics, identifiers, etc. are defined and published allowing
anyone to implement the extended functionality.
Specifications allow extensions for various reasons. Extensions allow
implementers to include features that they consider to be required by their
customers. Also, extensions, often define new features that may migrate into
future versions of the specifications. However, the use of extensions can
have a severe negative impact on interoperability. Some methods for enabling
extension have less impact on interoperability than other methods. For
example, a specification that allows private extensions (e.g., proprietary)
is highly likely to impede interoperability, whereas a specification than
permits only registered extensions partially mitigates the negative
impacts.
Checkpoints
To fulfill this checkpoint, a specification MUST state that extensions are disallowed and MUST indicate the conditions for when this holds true.
Rationale: if the specification writer wants to enhance interoperability by constrining implementer extensions, wording in the specification must indicate this.
If extensions are not allowed, then it should be clear to the reader that not only are extensions not allowed, but the circumstances under which they are not allowed. This is strict conformance. Strict conformance is often imposed on applications or content (e.g., a software program or document instance). This prohibition of extensions could be applied to a specific profile or module, rather than to the entire specification.
If extensions are not allowed, then make sure it is clear to the reader
that not only are extensions not allowed, but the circumstances under which
they are not allowed. The implementations of the specification precisely
implement the specification. This is strict conformance. Strict conformance
is often imposed on applications or content (e.g., a software program or is often imposed on applications or content document instance). This prohibition of extensions could be applied to a specific profile or module, rather than to the entire specification.
To fulfill this checkpoint, a specification MUST state
- the conditions under which extensions are allowed,
- the scope
of the extensions,
- their effect on conformance claims,
their anticipated
effect on interoperability, and - any limitations or restrictions on the use of
the extension
and MUST document the rationale for allowing extensions by referencing use cases and/or project requirements. It is not applicable if the specification doesn't allow extensions.
Rationale: readers should be able to understand the motivation for the inclusion of an extension and its intended use. Documenting the scope and rationale for extensions helps assess the impact of extensions on interoperability potentially serious negative impacts on
interoperability, and helps product developers understand the motivation for their inclusion and their intended use.
To fulfill this checkpoint, the specification MUST state that extensions can not negate or change support for required functionality. It is not applicable if extensions are not allowed.
An extension does not change the fact that an implementation needs to
support all required functionality in the specifications exactly as
specified; nor does it cause the non-conformance of functionality defined in
the specification. The specification can include statements such as:
- Each implementation shall fully support all required functionality of
the specification exactly as specified.
- Extensions shall not re-define semantics for existing functions.
- The use of extensions shall not contradict nor cause the
non-conformance of functionality defined in the specification.
To fulfill this checkpoint, a specification MUST provide a standard way of defining the extension or a standard way of being "non-standard". It is not applicable if extensions are not allowed.
One mechanism to allow extensions within a specification is to provide a
standard way of defining the extension or a "standard way of being
non-standard". This helps to ensure predictable handling of extensions, that
is, its recognition as such and the appropriate actions (i.e., to ignore or
to implement).
The nature of the extension dictates the method for defining
the extension. It may be possible to define a generic function or mechanism
that indicates external functionality. This external function may take the
form of an escape or control character or may be an identifier, the presence
of indicates that an extension follows. Another method, especially when
extending a list of numeric parameters is to use a scheme where positive
values represent standardized values and negative values are reserved for
private extensions.
To fulfill this checkpoint a specification MUST define a registration mechanism for each extensions mechanisemrequire that the syntax and semantics of the extension be publicly documented. It is not applicable if extensions are not allowed.
Rationale: public availability with a full description allows the extension to be implemented by anyone without prior arrangement. This enhances interoperability by allowing the same functionality to be uniformly implemented across different implementations.
Rationale: registration is a procedure that allows extensions to be acknowledged and made available to the public. Registration provides for a degree of rigor and
technical review for any proposed extension. Typically the WG would be responsible for processing the
registration of an extension, thus ensuring adequate quality of a proposed
extension and a technical description sufficient to be uniformly
implementable. Often registered extensions may migrate into a later version of the specification.It also allows to identify needs for a later version of the specification.
[Issue. This was raised as an issue in QAWG project review (member-only), but
we never got to it on the agenda.]
To fulfill this checkpoint, a specification MUST require thatindicate via conformance requirements that implementations haveprovide a mode under which it can be directed tothey produce only conforming files
(documents)content or to operate in a strictly conforming manner. This checkpoint is not applicable if extensions are not allowed.
Rationale: This checkpoint can be used to ensure that there is a way to produce (generate) only conforming content. It is applicable to specifications that identify producer of content as one of its classes of products. @@@ Shouldn't this be moved in the applicability clause instead?
To fullfill this checkpoint, a specification MUST have a link in the table of contents to informations about any extensions mechanism.
Rationale: the reader must be able to easily identify and locate information about extensions and extensibility. A link from the table of contents (TOC)
provides this ability.
The form of TOC linkage can vary, depending on the
style of the specification — some have only a high-level TOC, some have a detailed TOC, and some have both. This checkpoint
could be satisfied by TOC links
to specific extensibility section(s) from a detailed TOC. For a high-level TOC, it could be satisfied by a link to a
conformance clause section that either contains or points to extensibility
information. It could be satisfied by both of the two previous when both
types of TOC are present.
A conformance clause is a part or collection of parts of a specification that defines the requirements, criteria, or conditions to be satisfied by an
implementation or application in order to claim conformance. Typically the
conformance clause is a high-level description of what is required of
implementations and applications.
Guideline 3, "conformance policy" is
related to this guideline. Guideline 3 focuses on the establishment and scope
of definition of a conformance policy, while this Guideline 10 focuses (among
other topics) on how and where to document it.
Checkpoints
To fulfill this checkpoint, a specification MUST document its conformance policy and specific conformance requirements.
To fulfill this checkpoint, a specification MUST document its conformance policy and specific conformance requirements in a dedicated section of the document.
Rationale: having the conformance clause exist as a separate section within the specification makes it clearly identifiable, allowing a reader to find the
overall conformance policy, as well as all specific conformance provisions
from a single starting point.
To fulfill this checkpoint, a specification MUST have a link in the table of contents to its conformance clause.
Rationale: it must be possible for the reader to start at the table of contents and find all aspects of the conformance requirements, including the overall
policy.
Make normative reference to specifications on which
the current specification depends
A specification depends on another specification when it relies on or requires functionality (or behavior) from the other specification in order to work (function) correctly. This other specification provides a necessary condition or functionality.
To fulfill this checkpoint, a specification MUST have normative references to any specification it depends on and MUST describe the relationship between the specifications and any conformance implications
Rationale: dependence on other specifications
affects the conformance boundaries of the current specification, and thereby
affects the requirements on conformant products.
Often a specification is dependent on other specifications or portions of
specifications.For example, SVG 1.0 requires that the class of product
called "user agent" be consistent with the XML 1.0 Recommendation [XML10] and (conditionally) support Cascading Style Sheets, level
2 [CSS2].
It must be possible for the reader to determine, from the conformance
clause, if:
- there is only one class of product specified,
- there are no profiles,
- there is no division of the technology into modules,
- there are no deprecated features,
- there are no functional levels,
- there are no discretionary items,
- extensions are not allowed.
This requirement applies separately to each dimension. For each dimension
where variability is permitted, see the checkpoint about making explicit
statements and justifications, under each respective guideline 2-9.
This checkpoint is not applicable for specifications (drafts and
Recommendations) that are issued before this document is final. Although such
legacy documents are exempt from these requirements to make explicit
statements of non-use of dimensions, the respective checkpoints still apply
for dimensions that are used.
A specification may differentiate conformance claims by designating
different degrees or types of conformance in order to apply and group
requirements according to modules, profiles, levels, or priorities. When a
conformance claim is linked to functionality, impact and/or incremental
degrees of implementation, the term 'conformance level' is often used to
indicate the varying degrees of conformance. The WG includes in the specification the way they
want people to claim their conformance.
Checkpoints
To fulfill this checkpoint, a specification MUST identify and define all conformance designations.
In current W3C practice, a number of different naming conventions are used
to label conformance, in cases where there is not a single, monolithic
(strict) conformance definition. The naming convention used to label the
conformance can provide useful information. Degrees, for example, implies
incremental importance or difficulty. This Specification Guidelines document
uses "degrees" for example, to refer to three successively more demanding
degrees of conformance (A, AA, AAA).
Each specification must
- clearly define the conformance naming convention, and identify and
define all conformance designations.
Functional (technology) specifications commonly use groupings of
functionality to distinguish among conformance designations. For example,
SVG Mobile [SVG-MOBILE] defines three
conformance categories as three nested profiles — Tiny, Basic, and Full --
based on the modularization
description of SVG
1.1 (Scalable Vector Graphics 1.1, [SVG11], section 1.1.2). Each of the profiles is equivalent
to a functional level that subsumes the next lower level (if any), providing
additional functionality and/or complexity.
The conformance designations of the guidelines documents of WAI and the QA
Framework, by comparison, reflect the a target object's satisfaction of
successively larger sets of prioritized checkpoints. A basic conformance
designation (A) is associated with the Priority 1 checkpoints. The other
designations, for AA (double-A) and AAA (triple-A), are associated with the
addition respectively of all Priority 2 and all Priority 3 checkpoints.
Examples: Web Content Accessibility Guidelines 1.0 [WCAG10]), in which the ; and, QA Framework:
Specification Guidelines (this document, see Conformance section.)
To fulfill this checkpoint, a specification MUST provide specific wording of the claim and the specific wording MUST at least include the specification name, its version, the conformance level satisfied and information about the subject that which is claiming conformance and the date of the claim.
Some of this need to be in the ET doc
A well-formed conformance claim includes: date of the claim, specification
name, date and version, URI of the specification, conformance level
satisfied, and information about the subject (that which is claiming
conformance). Information about the subject refers to information such as,
the name of the software or software component, version information, and
operating environment.
To fulfill this checkpoint, a specification MUST provide a conformance disclaimer.
Rationale: although it is possible to prove with certainty when something does not conform, the reverse is not necessarily true. Especially for functional
specifications, where a claim goes beyond syntax testing, a claim of
conformance is not a guarantee that the claimant is 100% conforming with the
specification. A disclaimer can help clarify the meaning of a conformance
claim as well as its limitations. For example, this document contains a
conformance disclaimer.
To fulfill this checkpoint, a specification MUST NOT include any restriction about who can make a claim nor where claims can be published.
Claimants (or relevant assuring parties) are solely responsible for the
validity of their claims, keeping claims up to date, and proper use of the
conformance icons. I don't think this brings anything useful As of the publication of this document, W3C does not act
as an assuring party, but it may do so in the future, or it may establish
recommendations for assuring parties. Claimants are expected to modify or
retract a claim if it may be demonstrated that the claim is not valid.
To fulfill this checkpoint, a specification MUST have a link in the table of contents to informations on conformance claims.
Rationale: the reader should be able to easily identify and locate the information on
how to make conformance claims. A link from the table of contents (TOC)
provides this ability.
The form of TOC linkage can vary, depending on the
style of the specification — some have only a high-level TOC, some have a detailed TOC, and some have both. This checkpoint
could be satisfied by TOC links
to specific conformance-claims text from a detailed TOC. For a high-level TOC, it could be satisfied by a link to a
conformance clause section that either contains or points to
conformance-claims information. It could be satisfied by both of the two
previous when both types of TOC
are present.
An Implementation Conformance Statement (ICS) provides a mechanism whereby a supplier of an implementation of the specification provides information
about the implementation in a standardized manner. It is used to indicate
which capabilities and options have been implemented, as well as the
limitations of the implementation. An ICS usually takes the form of a
questionnaire where product implementors report on the conformance of their
product to the named specification.
An ICS is useful in disclosing optional functionality and discretionary
behavior and values. The results of the ICS can be used to identify the
subset of test cases from a conformance test suite that are applicable to the
implementation to be tested. This will allow the implementation to be tested
for conformance against only the relevant requirements.
The basic and detailed information that an ICS provides can also be used
to assess and deduce the interoperability potential of two or more
products.
Checkpoints
To fulfill this checkpoint, a specification MUST either:
- include or reference an Implementation Conformance Statement.
- explain why an ICS is not needed
Rationale: the inclusion of an ICS may not be applicable to all specifications. A specification's ICS can be thought of as providing a minimal list of items supported by the implementation, capturing information the WG deems necessary to support conformance claims.
How an ICS can be normative? Is an implementation that provdes an ICS not exactly equal to the one of the spec not conformant? On what class of product is this requirement set? If an ICS is included as part of the specification, indicate whether it is a normative or informative part of the specification.
To fulfill this checkpoint, a specification MUST include the ICS as part of its conformance claim requirements.
This checkpoint is not applicable, if an ICS is not included in the specification.
Rationale: the ICS is coupled with the requirements for making a conformance claim (guideline 11), thus providing specific information about the implementation and substantiating the conformance claim.an ICS provides specific information about the implementation and can be helpful in substantiating the conformance claim.
There is a lot to be said for consistency and clarity within a document -
it facilitates the understanding and comprehension of the document. Authors
and editors of specifications should already be familiar with the W3C
Manual of Style [STYLE-MAN] and
Publication Rules (member-only) [PUBRULES], which help to achieve this. With
respect to conformance, it is important to provide clear and unambiguous
statements, so that the reader knows what is required in order to claim
conformance and what is optional. To achieve this objective, throughout the
document, employ uniformity of structure and style, and consistency of
terminology and phraseology.
Checkpoints
To fulfill this checkpoint, a specification MUST use RFC 2119 keywords to denote wheter or not requirements are mandatory, optional, or suggested.
Rationale: Using these keywords helps to identify the
testable statements in a specification.
Normative statements are the prescriptive parts of the specification
whereas informative statements are for informational purposes and assist in
the understanding or use of the specification.
To fulfill this checkpoint, a specification MUST distinguish normative text from informative text.
Rationale: it is important that the
reader be able to distinguish between normative and informative statements in
order to know what is required to claim conformance. SMIL 2.0 is an example,
indicating within every subsection whether it is normative or informative,
and even separately labelling pieces of subsections that contain both kinds
of text.
Applying the principles of the Web Content Accessibility Guidelines
1.0 [WCAG10] and Internationalization
guidelines not only ensures accessibility and internationalization, but
also contributes to the principles of conformance - clear, unambiguous,
testable statements. For example, use simpler words to express your ideas,
markup text with structural elements, add markup to distinguish common words
from keywords.
To fulfill this checkpoint, a specification MUST use identical wording to express identical provisions, and analogous wording to express analogous provisions @@@ Is that testable?.
To fulfill this checkpoint, a specification MUST provide at least one navigation mechanism that allows the reader to locate all conformance-related information that is relevant to the specification. The mechanism MUST minimally locate:
- the conformance clause;
- any conformance section;
- unambiguous statements about those DoV that the specification employs, from amongst the eight defined in this specification;
- requirements for conformance claims.
Rationale: A reader must be able to easily identify and locate all the information necessary to understand the conformance policy and related conformance information without having to read the document from cover to cover. A navigation mechanism adds to the usability of the specification.
Using a W3C endorsed grammar language (DTD or XML Schema) provides
control over the information conveyed in the specification. This allows for
and facilitates automatic generation of test materials, more detailed
reporting of test results as well as specification coverage.
Examples include the XML and DOM Working Groups, that both use the
xmlspec
DTD.
Using a granular grammar to author a specification draws further on
separation of content and presentation and simplifies the task of generating
readable versions of the specification, maintaining the possibility to
generate test materials from the granular version of the specification. In
addition, using a grammar to author the specification makes it easier to
logically group the constituents of the specification, thus adding control
over interpretation and implementation.
Using a grammar greatly simplifies controlling conformance with W3C
publication rules and guidelines/checkpoints. Also, having written the
specification using a grammar, automated validation with regard to these
aspects is simplified.
Finally, using an advanced schema for specification authoring allows for
greater control over coverage of the specification in the Test Suite.
Checkpoints
One example is the DTD noted above, used by
a number of W3C specifications. There are other examples that use XHTML, with
the application of class attributes to convey significant
information about structure or meaning.
Some specifications test assertions as part of the specification,
and more should.
A test assertion is a statement of behavior, action or
condition that can be measured or tested. It is derived from the
specification's requirements and bridges the gap between the narrative of the
specification and the test cases. Each test assertion is an independent,
complete, testable statement for requirements in the specification. Each test
assertion results in one or more test cases. Multiple test assertions can be
combined to form a test case, in this case one tests multiple facets of a
particular behavior.
Checkpoints
To fulfill this checkpoint, a specification MUST include or reference normatively a list of test assertions stated in it. @@@ Here (or in an adjacent CP) should come probably the discussion on normativity and conflict resolution?
In order to enable pointing to test assertions from tests as well as to
give a map of the specification from the point of view of tests, use a
mechanism for making explicit test assertions in the specification.
Rationale: providing test assertions as part of the specification facilitates and promotes the development of test materials. Tests can point directly to the test assertion in the specification. Specific benefits include:
- Detailed reporting when testing an implementation using the test;
- Detailed control over what parts of a specification an implementation
supports, grouped by behavior, technical aspect (method/interface) or
other conceptual grouping;
- if the test assertions are included in the specification, they are publicly
reviewed and agreed to;
To fulfill this checkpoint, a specification MUST provide a mechanism linking each test assertion to the part of the specification it is stated.
Rationale: this allows both to ensure consistency between the specification and the test assertions list and to facilitate building a test suite framework based on the test assertions list.
Where applicable, use an existing markup vocabulary for making explicit
the test assertions for the specification. If possible, use markup provided
in QA Framework: Specification Examples & Techniques [SPEC-EXTECH]. Otherwise construct test assertion
markup according to that document and/or QA Framework: Test Examples
& Techniques [TEST-EXTECH].
There are different types of technologies that are standardized by W3C
specifications, and this checkpoint applies in different ways to those. For
API
specifications, such as DOM,
the intended behavior is the algorithm output; the specification contains
wording on what the expected result of applying a particular method on an
interface is. On user-centric specifications, such as WAI guidelines
specifications, the intended behavior is not so much a question of testing
algorithms, but rather how user agents should behave given different input or
how markup should be designed. In this case, intended behavior is more a
question of parsing documents. On processor specifications, such as XML, the intended behavior is,
for example, preserving or expanding entity references, and the intended
behavior is a particular state after processing a document.
Following the guideline below, group test assertions and statements of
intended behavior in the specification, or group the pointer to the test
assertions together with the statement of intended behavior in the
specification (in case the test assertion is, for example, given in an
appendix).
This section defines conformance of Working Group specifications — i.e.,
technical reports — to the requirements of this QA Framework guidelines
specification. The requirements of this guidelines specification are detailed
in the checkpoints of the preceding "Guidelines" chapter, and apply to the
technical reports produced by Working Groups.
Test assertions
The test assertions of this Specification Guidelines document are found in
the prioritized checkpoints. A checkpoint will contain at least one, and may
contain multiple individual requirements. These requirements are the test
assertions of this specification. A checkpoint is satisfied by satisfying all
of the individual requirements. Failing one individual mandatory requirement means that
the checkpoint is not satisfied. Mandatory requirements are those that use the conformance keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", or "SHALL NOT".
Conformance definition
This section defines three degrees of conformance to this guidelines
specification:
- A-Conforming: all Priority 1 checkpoints are
satisfied;
- AA-Conforming: all Priority 1 and Priority 2
checkpoints are satisfied;
- AAA-Conforming: all Priority 1, Priority 2, and
Priority 3 checkpoints are satisfied;
A specification conforms to the QA Framework: Specification
Guidelines at degree X (A,
AA, or AAA) if the Working Group meets at
least all degree X conformance requirements.
To make an assertion about conformance to this document, specify:
- The guidelines title: QA Framework: Specification
Guidelines
- The guidelines URI: http://www.w3.org/TR/qaframe-spec/
- The degree of conformance satisfied: A-Conforming, AA-Conforming, or
AAA-Conforming.
Example:
This specification conforms to W3C's QA Framework: Specification
Guidelines, available at http://www.w3.org/TR/qaframe-spec/,
AA-Conforming.
Conformance disclaimer
The checkpoints of this guidelines specification present verifiable
conformance requirements about the specifications (technical reports) that
Working Groups produce. As with any verifiable test requirements, it is also
true of these specification requirements that:
- Passing all of the requirements to achieve a given degree of
conformance — A, AA, or AAA — does not guarantee that the subject
specification is well-suited to or will achieve its intended purposes,
nor does it guarantee the quality or suitability of test materials
produced from the specification.
- Failing to achieve conformance degree of at least A-conforming does not
mean that the subject specification is necessarily deficient to its
intended purposes, nor does it mean that it is an unacceptable basis for
the development of quality test materials. It means that the
specification has failed one or more checkpoints that best-practice
experience has shown to improve the testability and usability of
specifications, and to facilitate the timely and successful development
and maintenance of quality test materials based on the specification.
[@@Ed note. under construction.] This section contains terms used in this
specification, with functional or contextual definitions appropriate for this
specification. See also [QA-GLOSSARY]. Some terms
in this section have been borrowed or adapted from other specifications.
- conditional conformance
- [@@Ed note. we don't use it yet, but do use its companion "strict
conformance"]
- conformance clause
- a part or collection of parts of a specification that defines the
requirements, criteria, or conditions to be satisfied by an
implementation or application in order to claim conformance
- conformance level
- a variety of conformance designation. Other designations include
conformance category, conformance degree, conformance xxx,...
"Conformance level" is discouraged in new specifications, because of
confusion with "functional level".
- dimensions of variability
- the ways in which different products that are conformant to a
specification may vary among themselves. In this Specification
Guidelines document, the dimensions of variability are used to help
organize, classify and assess the conformance characteristics of W3C
specifications
- discretionary items
- deliberate and explicit grants of discretion by the specification, to
the implementations, that describe or allow optionality of behavior,
functionality, parameter values, error handling, etc.
- functional level
- a technology subset that is one of a hierarchy of nested subsets,
ranging from minimal or core functionality to full or complete
functionally.
- implementation conformance statement (ICS)
- a mechanism for providing standardized information about an
implementation of a named specification, usually in the form of a
questionnaire on which product implementers report about the product's
conformance to the specification. An ICS is used to indicate which
requirements, capabilities and options have and have not been
implemented.
- informative text
- text in a specification whose purpose is informational or assistive
in the understanding or use of the specification, and which contains no
test assertions or conformance requirements.
- level
- a commonly used shorthand for functional level.
- module
- a collection of semantically-related elements, attributes, and
attribute values that represents a unit of functionality. Modules are
non-hierarchical, discrete divisions that are defined in coherent
sets.
- normative text
- text in a specification which is prescriptive or contains conformance
requirements.
- profile
- a subset of a technology that is tailored to meet specific functional
requirements of a particular application community. A profile may
address a single technology; or, a profile can also group a set of
technologies (i.e., from different specifications) and define how they
operate together. Profiles may be based on hardware considerations
associated with target product classes, or they may be driven by other
functional requirements of their target communities.
- profiling
- a method for defining subsets of a technology by identifying the
functionality, parameters, options, and/or implementation requirements
necessary to satisfy the requirements of a particular community of
users.
- strict conformance
- conformance of an implementation that employs only the requirements
and/or functionality defined in the specification and no more (i.e., no
extensions to the specification are implemented).
- test assertion
- any sentence or equivalent assemblage of words and phrases that
prescribes the behavior that must be obtained when a stimulus occurs
under a certain set of conditions. (See also QA Glossary
[QA-GLOSSARY].)
- unconditional conformance
- [Ed note. @@we don't use it yet, but do use its companion "strict
conformance"]
- use case
- a specification mechanism or technique that captures the ways a
specification would be used, including the set of interactions between
the user and the specification as well as the services, tasks, and
functions the specification is required to perform.
- user scenario
- an instance of a use case, that represents a single path through the
use case. Thus, there may be a scenario for the main flow through the
use case and another scenarios for each possible variation of flow
through the use case (e.g., representing each option).
The following QA Working Group and Interest Group participants have
contributed significantly to the content of this document:
- Daniel Dardailler (W3C)
- Dimitris Dimitriadis (Ontologicon)
- Karl DuBost (W3C)
- Peter Fawcett (RealNetworks)
- Kirill Gavrylyuk (Microsoft)
- Dominique Hazael-Massieux (W3C)
- Lofton Henderson (CGM Open)
- Ian Jacobs (W3C)
- David Marston (IBM Research)
- Jack Morrison (Sun Microsystems)
- Lynne Rosenthal (NIST)
- Alex Rousskov (Measurement Factory)
- Mark Skall (NIST)
- Andrew Thackrah (Open Group)
- Olivier Thereaux (W3C)
- CSS2
- Cascading Style
Sheets, Level 2, W3C Recommendation, 12 May 1998, available
at http://www.w3.org/TR/REC-CSS2.
- MATHML20
- Mathematical Markup
Language (MathML) Version 2.0, W3C Recommendation, 21
February 2001, available at http://www.w3.org/TR/MathML2/.
- PUBRULES
- W3C Publication
Rules, available at http://www.w3.org/Guide/pubrules.html
(member-only).
- QA-GLOSSARY
- Comprehensive glossary of QA
terminology. (Under construction, at
http://www.w3.org/QA/Glossary.)
- QAF-INTRO
- QA
Framework: Introduction, L. Henderson, D. Dimitriadis, K.
Gavrylyuk, L. Rosenthal, Eds., W3C Working Draft, May 2002, companion
version to this document, available at
http://www.w3.org/QA/WG/2002/framework-20020826/qaframe-intro.
- QAF-OPS
- QA
Framework: Operational Guidelines, K. Gavrylyuk, D.
Dimitriadis, L. Henderson, L. Rosenthal, Eds., W3C Working Draft, May
2002, companion version to this document, available at
http://www.w3.org/QA/WG/2002/framework-20020826/qaframe-ops.
- QAF-TEST
- QA Framework: Test Guidelines, not yet published, see Table of Seven (at
http://www.w3.org/QA/WG/#docs), for most-recent links to any WG-only or
published version(s).
- QAIG
- Quality Assurance Interest
Group of the W3C QA Activity, which may be found at
http://www.w3.org/QA/IG/.
- QAWG
- Quality Assurance Working
Group of the W3C QA Activity, which may be found at
http://www.w3.org/QA/WG/.
- RFC2119
- Key words for use
in RFCs to Indicate Requirement Levels, March 1997,
available at http://www.ietf.org/rfc/rfc2119.txt.
- SMIL20
- Synchronized
Multimedia
Integration Language (SMIL 2.0), W3C Recommendation, 07
August 2001, available at http://www.w3.org/TR/smil20/.
- SPEC-CHECKLIST
- An appendix to this specification guidelines document presents all
checkpoints in tabular form. Available at
http://www.w3.org/QA/WG/2002/framework-20020826/qaframe-spec-checklist.
- SPEC-EXTECH
- QA Framework: Specification Examples & Techniques, available at http://www.w3.org/QA/WG/2002/11/qaframe-spec-extech.
- STYLE-MAN
- W3C Manual of
Style, summarizing the style and publication rules for W3C
technical reports, available at http://www.w3.org/2001/06/manual/.
- SVG11
- Scalable Vector Graphics
(SVG) 1.1 Specification, D. Jackson, J. Ferraiolo, J.
Fujisawa, Eds., W3C Candidate Recommendation 30 April 2002, available
at http://www.w3.org/TR/SVG11/.
- SVG-MOBILE
- Mobile SVG Profiles:
SVG Tiny and SVG Basic, T. Capin, Editor, W3C Candidate
Recommendation, 30 April 2002, available at
http://www.w3.org/TR/SVGMobile/.
- TEST-EXTECH
- "QA Framework: Test Examples & Techniques", not yet published,
see Table of Seven (at
http://www.w3.org/QA/WG/#docs), for most-recent links to any WG-only or
published version(s).
- UAAG10
- User Agent Accessibility
Guidelines 1.0, I. Jacobs, J. Gunderson, E. Hansen, Eds.,
W3C Candidate Recommendation, 12 September 2001, available at
http://www.w3.org/TR/UAAG10/.
- W3C-TR
- Location of all published W3C
technical reports, see http://www.w3.org/TR/.
- WCAG10
- Web Content
Accessibility Guidelines 1.0, W. Chisholm, I. Jacobs, G.
Vanderheiden, Eds., W3C Recommendation, 5 May 1999, available at
http://www.w3.org/TR/WCAG10/.
- XHTML-MOD
- Modularization of
XHTML, M. Altheim, F. Boumphrey, S. Dooley, S. McCarron, S.
Schnitzenbaumer, T. Wugofski,Eds., W3C Recommendation, 10 April 2001,
available at http://www.w3.org/TR/xhtml-modularization/.
- XHTML-BASIC
- XHTML
Basic, M. Baker, M. Ishikawa, S. Matsui, P. Stark, T.
Wugofski, T. Yamakami, Eds., W3C Recommendation, 19 December 2000,
available at http://www.w3.org/TR/xhtml-basic/.
- XHTML11
- XHTML 1.1 -
Module-based XHTML, M. Altheim, S. McCarron, Eds., W3C
Recommendation, 31 May 2001, available at
http://www.w3.org/TR/xhtml11/
- XML10
- Extensible Markup
Language (XML) 1.0 (Second Edition), T. Bray, J. Paoli, C.
M. Sperberg-McQueen, E. Maler, Eds., W3C Recommendation, 6 October
2000, available at http://www.w3.org/TR/REC-xml.
- XML-NAMES
- Namespaces in
XML, T. Bray, D. Hollander, A. Layman, Eds., W3C
Recommendation, 14-January-1999, available at
http://www.w3.org/TR/1999/REC-xml-names-19990114/.
- XML-SCHEMA
- XML Schema Part 1:
Structures, W3C Recommendation, 2 May 2001, available at
http://www.w3.org/TR/xmlschema-1/.
- XPATH10
- XML Path Language (XPath)
Version 1.0, W3C Recommendation, 16 November 1999, available
at http://www.w3.org/TR/xpath.
- XPOINTER
- XML
Pointer Language (XPointer) Version 1.0, W3C Candidate
Recommendation, 11 September 2001, available at
http://www.w3.org/TR/2001/CR-xptr-20010911/
- XSLT10
- XSL Transformations (XSLT)
Version 1.0, W3C Recommendation, 16 November 1999, available
at http://www.w3.org/TR/xslt.
- 2002-11-08, third published WD
While keeping most of the principles behind the second published WD, this version has re-ordered the guidelines in a more logical way, and takes a more formal approach in the design of CP, where all CP has a set of test assertions. Besides, repetitions have been dimished through factorization, and non-testable or arguable CP have been removed or marked as to be moved as examples and techniques. Finally, it integrates all the issues resolutions agreed during the QA WG Tokyo face-to-face meeting and the weeks following.
- the introduction integrates explicit scope and goals as required by the GL and has been cleaned of its repetitions
- usage of RFC 2119 has been clarified with the usage of uppercase keywords
- the dimensions of variability have now their own section in the introduction, regrouping the various bits previously scattered around
- ex-GL 14 on granular grammars has been removed, some of its content being integrated in the GL on test assertions
- ex-GL 6 on conformance policy has been moved ahead on GL 3, ex-GL 7 on levels has been grouped with its related GL on profiles and modules
- every CP has now a set of test assertions using RFC 2119 keywords; most of them have an explicit rationale and some of them an example; the stylesheet has been modified to highligh the test assertions
- the following CP (using numbering of the previous version) have been removed: 1.4 (
Ensure that every test assertion is covered by an example
), 2.3 (For each class of product, indicate minimal support requirements.
), 3.1 (Choose whether or not to have profiles.
), 3.2 (Include a table of contents entry.
), 4.1 (Choose whether or not to have modules.
), 4.2 (Include a table of contents entry.
), 6.5 (Include a table of contents entry.
), 7.1 (Address whether the specification uses or will use functional levels.
), 7.2 (Include a table of contents entry.
), 9.7 (Include a table of contents entry.
), 10.3 (Include a conformance clause entry in the table of contents
), 10.5 (Identify all dimensions of variability that are not used.
) 11.5 (Include a table of contents entry.
), 13.3 (Follow Web Accessibility Initiative and Internationalization Guidelines.
)
- CP 13.4 (
Provide a fast way to find conformance information
) is new
- overall, an effort has been put into using a consistent terminology across the specification and avoiding unclear or untestable statement
- the verbiage on each DoV has been vastly reduced or factorized in the DoV discussion in the introduction
- 2002-08-26, second published WD
-
Significantly reorganized and revised the first published WD. This
version produced as a series of editor's drafts. The changes below are
reverse chronological (most recent first), so more recent ones may
build on older ones.
- Handle negative disclaimers for DoV's via new
CK10.5.
- First cut at distinguishing specifications from technologies that
they describe (esp in profiles, modules, levels.)
- Add concept of SpecGL test assertions to "Conformance"
chapter.
- Define "use case" and "user scenario", revise GL1 & CK1.2 to
use them accordingly, clarify CK1.3 (Provide examples), add
rigorous CK1.4 (examples--TAs).
- Clean up "atomicity of modules" discussion, add atomicity to
CK4.3
- Harmonize priorities of CK8.1 & 8.2, 9.1 & 9.2.
- All GL14 and GL15 checkpoints to priority 2, except CK15.1;
tighten descriptions.
- All TOC checkpoints
to priority 2, except Conformance Clause (p1).
- Accommodate "Rules for Profiles" in GL2 categories and classes;
new CK3.6 and changes to 2.3.
- Add caveat to "Understanding and using.." (sec. 1.2), about
specifications that pre-date SpecGL.
- Rewrite CK11.1 to replace 'levels' in "conformance levels" w/
degrees, categories, etc (confusion with "functional levels").
- Change "levels" to "degrees" in SpecGL conformance clause.
- Change "discretionary behaviors" to "discretionary items" in GL8,
define three variants in GL8 verbiage.
- Extensive new prose in GL3 (profiles), GL4 (modules), GL7
(levels), describing potential relationships.
- Fixed definition of strict conformance, clarified definition and
usage of "conformance clause".
- Added "Definitions" section (in-spec glossary).
- Enhanced wording of all TOC checkpoints.
- For each of CK3.x (profiles), 4.x (modules), 7.x (levels),
x>1, added a "not applicable" disclaimer if the feature is not
used. (Except for the TOC checkpoints.)
- Change wording of CK7.x, eliminating "chosen", and add some new
explanation to 7.1
- Delete CK5.4 (conformance policy in conformance clause) and move
its verbiage to GL10 (conformance clause) and its checkpoints.
- Fix "Conformance" chapter, add "Checkpoint Priorities"
section.
- Change chapter title of "Navigating through this document" to
"Understanding and using this document"
- New text for Ckpt 3.4
- Added warnings about "excessive variability" to all
dimension-of-variability guidelines.
- Added to several DoV checkpoints a
requirement to explain/justify any variability dimension by use
cases and requirements.
- Fix separation between last two guidelines, "Granular Grammars"
and "Test Assertions".
- Introduce and motivate "dimensions of variability" (DoV) in sec
1.5
- Reordered guidelines (GL), split GL.5 into three new ones, GL.3,
GL.4, and GL.7, customized checkpoints to their topics (profiles,
modules, levels).
- Added new p3 checkpoint ("categorize specification") to (new)
GL.2
- Rewrote (old) GL.3, "conformance flavors", in terms of "specify
conformance policy, (new) GL.5.
- 2002-05-15 version
-
First published WD.