January 2002
Discuss this article
Bill Shannon is a Sun Distinguished Engineer and Spec Lead for the Java 2 Platform,
Enterprise Edition. Karen Tegan is Director of J2EE Compatibility and Platform Services
for Sun Microsystems. In this interview, Floyd Marinescu of
TheServerSide.com/The Middleware Company interviews Bill and Karen about J2EE, the
CTS and recent controversial events surrounding J2EE.
Marinescu: How does an application server become J2EE compatible?
Shannon: All J2EE licensees receive the J2EE Compatibility Test Suite (CTS). The licensee executes the CTS against their
implementation of the J2EE Platform Specification. Once their product has passed the CTS and has met all applicable
testing requirements, they submit a certification form to Sun Microsystems, verifying that their product has passed
the tests and met all compatibility requirements. Then the product can carry the Java Compatible, Enterprise Edition logo.
Marinescu: What kind of tests are included in the CTS?
Tegan: There are three types of tests included in the CTS: signature, API, and end-to-end or integration tests.
Signature tests verify that only the required elements of all specifications in the platform are implemented.
Compatibility means no more and no less than the required Java APIs may be
present, and the signature tests confirm this.
The API test checks that the product includes an implementation of all required APIs, and that the behavior of individual
APIs meets the requirements of the spec. Both the signature and API tests are not new in Java Compatibility. These have
been part of both J2SE compatibility tests and the tests for all Java optional packages provided by Sun.
The end-to-end integration tests are new to J2EE platform compatibility testing. They test the API and its underlying
mechanism or service provider. For example, many end-to-end tests extend from the client to the EJB container to the back
end database and return. Such tests use the platform the way an application would in a live interaction with a user.
Integration and end-to-end tests check that an application using certain combinations of APIs behaves as expected. They
ensure that data flows correctly between the front end application component and the database.
Marinescu: How does CTS differ from TCK in other technical areas?
Tegan: The term "Compatibility Test Suite" is just the name for the J2EE platform TCK. CTS serves the same purpose as any
TCK: to ensure compatibility of a product. But, CTS is more extensive than most TCKs because it includes the "end-to-end"
tests we described.
Marinescu: Some vendors who are J2EE compatible are tools or messaging vendors. Explain what it means for a messaging
vendor to be compatible?
Shannon: Each product that carries the Java Compatible, Enterprise Edition logo meets all requirements defined in the
J2EE Platform Specification. In order to receive the Java Compatible, Enterprise Edition brand, vendors must test and
ship their products with a full implementation of the J2EE platform. In many cases, vendors include the J2EE reference
implementation with their products.
For tools vendors, CTS tests the implementation of the J2EE platform integrated with their development products. For
messaging products, vendors must integrate their products with an implementation of the platform, then pass CTS. Anytime a
developer sees the Java Compatible, Enterprise Edition logo, they can be assured that the product includes a complete,
compatible implementation of the J2EE platform.
Marinescu: Does the J2EE CTS test for compatibility with the J2EE Connector Architecture?
Shannon: The J2EE 1.3 platform includes the requirement for the J2EE Connector 1.0 Architecture. The CTS tests for
all requirements of the J2EE 1.3 Platform Specification including Connectors.
Note that CTS tests only that the J2EE product meets the Connector requirements; it doesn't test any Resource Adapters
that might be included with the product.
Marinescu: What is the value of the Java Compatible, Enterprise Edition brand?
Tegan: Any product that carries the brand assures the customer that the requirements of the J2EE compatibility program
have been met. Such a product has been tested for compatibility with the J2EE specification, and has passed all those
tests. Developers can write applications to the J2EE specification--and companies can purchase such applications--and be
assured that they are portable across the more than 20 Java Compatible, Enterprise Edition
products available today. The brand assures that "Write Once, Run Anywhere" is carried into
enterprise applications.
Marinescu: What is new in the 1.3 tests?
Tegan: The J2EE 1.3 CTS has more than 15,000 tests. It includes all tests from 1.2, plus tests of the additional
requirements of the J2EE 1.3 platform specification.
Shannon: New in J2EE 1.3 are the Java Connector 1.0 Architecture, EJB 2.0 with Interoperability and CSIv2, Message
Driven Beans, improved CMP and finder query language, JMS 1.0.2, and JAXP 1.1.
Marinescu: How are the tests created?
Tegan: CTS engineering starts as soon as the JSR is filed. The CTS engineers work with Bill and other specification
leads to determine all the requirements of each spec. These are referred to as the test assertions. Each assertion has
at least one test case that refers to it. A list of all tests assertions and their respective specification location is
distributed to the J2EE licensees along with the CTS.
Marinescu: What do you test in a spec?
Tegan: The CTS can only test for the required elements of the J2EE Platform
Specification and that a product does the things that the specification
"requires". Words such as "must," "will," and "is required to" are turned into
test assertions by the CTS engineers and are tested on each licensee's product.
In some cases, the spec merely suggests how a product should behave, so
adherence isn't tested. The specification indicates these cases with words like
"may," "should," and "optionally." These are recommended functionality for the
platform, but portability isn't guaranteed.
Shannon: For instance, the J2EE platform spec describes how a product can
implement connection sharing, using the deployment information provided by the
application that describes which connections can safely be shared. No J2EE
product is required to implement connection sharing, or even to actually share
connections in all possible cases. Whether the connection is actually shared or
not, the other requirements of the J2EE spec must be obeyed. The CTS will test
these other requirements, without testing whether the connection is actually
shared.
Marinescu: Can the CTS be used as a test suite for product quality?
Tegan: Certainly a part of product quality is correct implementation of the
specification. The CTS can be used as part of a product quality test suite. In
fact, many licensees run the CTS against their intermediate builds of their
product. Though the CTS does exercise quite a wide range of the product
functionality, it isn't designed to be a product quality test suite. Products
will always have functionality beyond that tested by the CTS or required by the
specification.
The CTS isn't a stress test or a performance test. It doesn't test how a
product behaves under heavy load. It can't test how a product reacts to a
failure, such as an operating system crash or hardware failure. The transaction
support required by J2EE allows a product to robustly handle a failure of this
kind. But, the J2EE specification doesn't set specific failure handling
requirements. CTS can't test behavior of a product during such a failure. Good
product quality tests will want to test all these things.
Marinescu: We have heard vendors mentioning that they discovered bugs or flaws in the
tests themselves. How does the discovery of a CTS flaw affect the test suite and
the branding of other companies that previously passed the suite?
Tegan: Many bugs filed against CTS aren't problems with the test assertion
itself, but with test setup or configuration. There are requirements in the
J2EE platform specification where the implementation isn't specified. In these
areas, some tests have depended on implementation specific behaviors in the J2EE
reference implementation. A product that has previously passed these tests
still provides a valid implementation, because the test itself did not change.
The J2EE team works very closely with our licensees to fix any problem quickly.
Marinescu: Is the J2EE brand a one-shot thing or do I have to maintain it? If a
product is J2EE compatible for 1.2 , is it necessary to pass the 1.3 CTS?
Tegan: Each version or edition of a product that carries the Java Compatible,
Enterprise Edition brand must pass the tests and satisfy all testing
requirements. When a new product is released with the Java Compatible,
Enterprise Edition brand, it must pass the version of the CTS that was
available roughly six months previous.
Marinescu: Can licensees ship implementations of new APIs or features for the next
version of J2EE in a currently shipping product?
Shannon: The CTS requires that a product contain exactly the required versions
of required APIs; older or newer versions aren't allowed. The required elements are defined by the platform
specification. In order to maintain platform completeness and prevent platform fragmentation, many of the
specifications included in J2EE do not have a separate TCK. EJB, Connectors, and JTA are examples of Java
APIs that can only be provided as part of a J2EE compatible product.
Tegan: This means a developer will know exactly what features are available with
any version of J2EE. The application doesn't need to check which version of each
API is available. The application can't even *accidentally* use a feature from a
newer version of an API, which would reduce application portability. Instead, an
application knows that it has, for example, the J2EE 1.3 APIs, no more and no
less.
Shannon: One important exception to this rule is critical to allowing Sun to deliver quality specifications through the
JCP. A *non-final* product -- that is, an "early access" or "beta test" version -- doesn't need to meet compatibility
requirements. Of course, these products may not use the Java Compatible brand. This allows vendors to ship preliminary
implementations of specifications still under development. Users can use these implementations to provide feedback on
the APIs. This helps us design APIs that best meet the needs of real users.
Another important exception is for Endorsed Standards. Endorsed Standards are Java APIs defined by standards bodies
other than the JCP,such as the W3C DOM APIs. Vendors are allowed to include newer versions of Endorsed Standards in
their products.
Marinescu: What is Sun's point of view in the debate over whether J2EE licensing restricts open source J2EE products?
Shannon: Sun participates in open source because it helps spark innovation, improve software quality, and fosters
community. The source code for the J2EE reference implementation is made available publicly as part of the Sun
Community Source Licensing program.
Sun supports open source developers because their efforts are consistent with Sun's own computing vision which uses open
standards and non-proprietary interfaces. Sun's goal is to make our software as open as possible while ensuring portability
and WORA.
Tegan: At the same time, having a strong brand and compatibility standards are important to the development of a robust
market for J2EE platform products, tools, and components. The J2EE Compatible brand has achieved significant momentum
over the past two years, and we want to make sure that any open source efforts don't impact the viability of that
effort.
Marinescu: Why are there 5000 tests in 1.2 and 15000 in 1.3?
Shannon: The J2EE 1.3 Platform itself had major additions over version 1.2. The
addition of JMS, Connectors and EJB enhancements including Interoperability and
CSIv2 required a significant number of additional tests. In general, the CTS
grows with the size of the platform requirements.
Marinescu: What have Sun and the Java Software team learned in working with licensees
on CTS?
Tegan: We have learned that Compatibility matters to our licensees and their customers, and that it is a
continuous process. Even though the CTS is large and tests a complex platform, the J2EE licensees met the
challenge. You can't count on specs alone for technical correctness. It takes all three areas, the specification,
the reference implementation and the compatibility tests to get it right. The CTS adds tremendous value to both
J2EE product providers and enterprise application developers. Compatibility isn't a one time thing, it's
a continual part of the development process.
Marinescu: We have heard the CTS is hard to run. What is Sun doing to make it easier?
Tegan: The CTS tests a complex environment. Today, an implementation can include vendor-specific platform requirements.
To make the CTS itself portable, it abstracts the vendor specific classes into a porting package.
Once a vendor has implemented the complete platform, it is easy to run and repeat executions of the complete or
sections of the CTS. The CTS uses JavaTest which is available through the JCP as part of the Java Test Development
Kit (JTDK).
Marinescu: We have heard that JAXP is moving from EE to SE; what is the relationship between JCK & CTS?
Shannon: One requirement of the J2EE platform is the appropriate underlying J2SE platform -- one that has passed the
appropriate Java Compatibility Kit (JCK) tests. The CTS also assumes that there is a Java Compatible, Standard Edition
implementation underneath. Once a platform component technology migrates from J2EE into J2SE, CTS no longer includes
signature or API tests -- they move to the JCK. The CTS may, however, continue to exercise the end-to-end and integration
tests for that component.
Right now, JAXP is available as a separate technology, with a separate reference implementation and TCK. Therefore,
JAXP can be combined with other technologies, including Java platform editions that don't include JAXP, such as J2SE 1.3
and J2EE 1.2.
J2EE 1.3 uses JAXP and requires, at a minimum, J2SE 1.3. Since SE 1.3 doesn't include JAXP, JAXP 1.1 is included in
J2EE 1.3, and the J2EE 1.3 CTS includes the JAXP 1.1 TCK.
J2EE 1.4 will require J2SE 1.4 at a minimum. Since JAXP 1.1 will be moving into J2SE 1.4, the JAXP 1.1 TCK will
move into the JCK for J2SE 1.4. As a result, the J2EE 1.4 CTS will not need to include the JAXP TCK.
Marinescu: How many J2EE licensees and certified products are there today?
Tegan: There are 20 Java Compatible, Enterprise Edition 1.2 products available today.
Check out http://java.sun.com/j2ee/compatibility.html
for the complete list of J2EE Compatible products and pointers to the licensee implementations. There are also 4 Java
Compatible, Enterprise Edition 1.3 products available today.
Stay tuned for product announcements in the coming weeks as vendors finish their compatibility testing for our J2EE 1.3
Launch Event in San Francisco.
Marinescu: Many of our members have mentioned that even CORBA vendors can't properly interoperate - so why was IIOP
standardized as the RMI transport in J2EE 1.3?
Shannon: The IIOP standard was already supported by the Java platform and provided the industry's best hope for a
standard interoperability protocol at the time J2EE 1.3 was defined -- although, in the future, we expect web service
protocols such as SOAP to also provide such interoperability.
In addition, we drove the definition of the security interoperability component of IIOP through the OMG in order to fill
in the major missing piece that was needed for J2EE. We believe our compatibility testing program and licensee support
program will allow us to achieve a real, useful level of J2EE interoperability.
Marinescu: Are there any plans on bundling JDO into J2EE?
Shannon: No, there are no plans to add JDO as a required component of J2EE. Some vendors are evaluating JDO for use in
their products. If there is sufficient demand from vendors and customers to include JDO in J2EE, we will consider
including it. So far, we have not seen such demand. Most vendors and users are happy with the Container Managed
Persistence capability added to EJB 2.0 in J2EE 1.3.
Marinescu: What features should we anticipate in J2EE 1.4?
Shannon: Web services, web services, and more web services! Support for web service standards such as SOAP/HTTP and
WSDL is the primary goal of J2EE 1.4. J2EE 1.4 will be the best platform for deploying and accessing web services.
Much work is underway in the Java Community Process to define the components needed to supply full support for web
services. One of the major components, the JAX-RPC technology, will be delivered before J2EE 1.4 and will be usable
on J2EE 1.3 products.
J2EE 1.4 will also deliver on work in progress to improve the support for J2EE tools, and will provide minor
enhancements to existing APIs as required.
More detail on our thinking for J2EE 1.4 can be found on the JCP web site at
http://jcp.org/jsr/detail/151.jsp.
PRINTER FRIENDLY VERSION
|