<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en-us" xml:lang="en-us">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<meta name="copyright" content="Copyright (c) 2000, 2006 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
<meta name="DC.rights.owner" content="(C) Copyright 2000, 2006" />
<meta content="public" name="security" />
<meta content="index,follow" name="Robots" />
<meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
<meta content="reference" name="DC.Type" />
<meta name="DC.Title" content="J2EE Validators" />
<meta name="abstract" content="This table lists the validators that are available for the different project types and gives a brief description of each validator." />
<meta name="description" content="This table lists the validators that are available for the different project types and gives a brief description of each validator." />
<meta content="validation, J2EE validators, code validation" name="DC.subject" />
<meta content="validation, J2EE validators, code validation" name="keywords" />
<meta scheme="URI" name="DC.Relation" content="../topics/rvalerr.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/tjval.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="rvalidators" name="DC.Identifier" />
<meta content="en-us" name="DC.Language" />
<link href="../../org.eclipse.wst.doc.user/common.css" type="text/css" rel="stylesheet" />
<title>J2EE Validators</title>
</head>
<body id="rvalidators"><a name="rvalidators"><!-- --></a>


<h1 class="id_title">J2EE Validators</h1>



<div class="id_refbody"><p class="id_shortdesc">This table lists the validators that
are available for the different project types and gives a brief description
of each validator.</p>

<div class="anchor_topictop" />


<div class="tablenoborder"><table summary="" cellspacing="0" cellpadding="4" frame="border" border="1" rules="all">

<thead align="left">
<tr class="anchor_toprow">
<th valign="top" width="50%" id="N10073">Validator name</th>

<th valign="top" width="50%" id="N1007A">Description</th>

</tr>

</thead>

<tbody>
<tr class="id_appclientValidator">
<td align="left" valign="top" width="50%" headers="N10073 ">Application Client Validator</td>

<td align="left" valign="top" width="50%" headers="N1007A ">The Application Client Validator validates
the following Application Client project resources:   <ul>
<li>Deployment descriptor (application-client.xml)</li>

<li>EJB references</li>

<li>Resource references</li>

</ul>
</td>

</tr>

<tr class="id_connectorValidator">
<td valign="top" width="50%" headers="N10073 ">Connector Validator</td>

<td valign="top" width="50%" headers="N1007A ">The Connector validator checks for invalid J2EE specification
levels in connector projects.</td>

</tr>

<tr class="id_DTDValidator">
<td align="left" valign="top" width="50%" headers="N10073 ">DTD Validator</td>

<td align="left" valign="top" width="50%" headers="N1007A ">The DTD validator determines whether the
current state of a DTD is semantically valid. XML files are validated according
to the XML specification <a href="http://www.w3.org/TR/2000/REC-xml-20001006" target="_blank" title="">Extensible Markup Language (XML) 1.0</a> from
the W3C Web site. As well, the DTD validator checks for errors such as references
to entities and elements that do not exist.</td>

</tr>

<tr class="id_EARValidator">
<td align="left" valign="top" width="50%" headers="N10073 ">EAR Validator</td>

<td align="left" valign="top" width="50%" headers="N1007A ">The EAR Validator validates the following:
 <ul>
<li>EAR deployment descriptor (application.xml)</li>

<li>EJB references of all module projects in the enterprise application project</li>

<li>Security roles</li>

<li>Resource references</li>

<li>Manifest files for all contained or referenced modules and utility JAR
files</li>

<li>Target server consistency between the enterprise application project and
any utility and module projects</li>

<li>Existence of projects for each module defined in enterprise application</li>

</ul>
  <p>Note that the EAR Validator only ensures the validity and dependency
of the module projects with respect to the enterprise application project.</p>
</td>

</tr>

<tr class="id_EJBValidator">
<td align="left" valign="top" width="50%" headers="N10073 ">EJB Validator</td>

<td align="left" valign="top" width="50%" headers="N1007A ">The EJB Validator verifies that enterprise
beans contained in an EJB project comply with the Sun Enterprise JavaBeans™ Specifications
(1.1, 2.0, and 2.1), depending on the level of the bean. Code validation for
the EJB 1.0 specification is not supported.   <p>Specifically, the EJB Validator
validates the following resources: </p>
  <ul>
<li>Java™ .class
files that are members of an enterprise bean (home interface, remote interface,
enterprise bean class, and, if the bean is an entity bean, the key class)</li>

<li>ejb-jar.xml</li>

</ul>
</td>

</tr>

<tr class="id_ELValidator">
<td valign="top" width="50%" headers="N10073 ">EL Syntax Validator</td>

<td valign="top" width="50%" headers="N1007A ">&nbsp;</td>

</tr>

<tr class="id_HTMLValidator">
<td align="left" valign="top" width="50%" headers="N10073 ">HTML Syntax Validator</td>

<td align="left" valign="top" width="50%" headers="N1007A ">The HTML Syntax Validator validates HTML
basic syntax and HTML DTD compliance in the following Web project resources:
 <ul>
<li>HTML files</li>

<li>JSP files</li>

</ul>
</td>

</tr>

<tr class="id_JSPValidator">
<td align="left" valign="top" width="50%" headers="N10073 ">JSP Syntax Validator</td>

<td align="left" valign="top" width="50%" headers="N1007A ">The JSP Syntax Validator validates JSP files
in a project by translating them into the corresponding Java code
and then checking the Java code for compile errors.</td>

</tr>

<tr class="id_WARValidator">
<td align="left" valign="top" width="50%" headers="N10073 ">War Validator</td>

<td align="left" valign="top" width="50%" headers="N1007A ">The War Validator validates the following
web project resources:   <ul>
<li>Deployment descriptor (web.xml)</li>

<li>Servlets</li>

<li>Security roles</li>

<li>Servlet &amp; servlet mappings</li>

<li>EJB references</li>

</ul>
</td>

</tr>

<tr class="id_WSDLValidator">
<td valign="top" width="50%" headers="N10073 ">WSDL Validator</td>

<td valign="top" width="50%" headers="N1007A ">The WSDL validator checks the following in WSDL files: <ul>
<li>XML syntax</li>

<li>XML Schema types in the &lt;types&gt; section</li>

<li>Referential integrity of the various constructs in WSDL </li>

</ul>
The validator also includes an extension point to allow other validators
to be plugged into the WSDL validation to provide additional verification
of the WSDL file. Through this mechanism, interoperability is checked by validating
a WSDL file against WS-I Profiles. </td>

</tr>

<tr class="id_WSIValidator">
<td valign="top" width="50%" headers="N10073 ">WS-I Message Validator</td>

<td valign="top" width="50%" headers="N1007A ">WS-I Message validator checks SOAP messages against
WS-I Profiles. A user can capture and verify SOAP messages using the TCP/IP
Monitor. The validator checks a message log that is saved as a project resource
(.wsimsg). The log conforms to a format as specified by WS-I.</td>

</tr>

<tr class="id_XMLSchemaValidator">
<td align="left" valign="top" width="50%" headers="N10073 ">XML Schema Validator</td>

<td align="left" valign="top" width="50%" headers="N1007A ">The XML schema validator determines whether
the current state of an XML schema file is semantically valid. XML schemas
are validated according to the XML Schema specification <a href="http://www.w3.org/TR/xmlschema-1/" title="">XML Schema Part 1: Structures</a> from the W3C Web site.</td>

</tr>

<tr class="id_XMLValidator">
<td align="left" valign="top" width="50%" headers="N10073 ">XML Validator</td>

<td align="left" valign="top" width="50%" headers="N1007A ">The XML validator ensures that an XML file
is well-formed. It also verifies if an XML file is valid - that is, it follows
the constraints established in the DTD or XML schema the XML file is associated
with.</td>

</tr>

<tr class="anchor_bottomrow">
<td valign="top" width="50%" headers="N10073 ">&nbsp;</td>

<td valign="top" width="50%" headers="N1007A ">&nbsp;</td>

</tr>

</tbody>

</table>
</div>

<div class="anchor_topicbottom" />

</div>

<div><div class="reltasks"><strong>Related tasks</strong><br />
<div><a href="../topics/tjval.html" title="The workbench includes validators that check certain files in your enterprise application module projects for errors.">Validating code in enterprise applications</a></div>
</div>
<div class="relref"><strong>Related reference</strong><br />
<div><a href="../topics/rvalerr.html" title="You may encounter these common error messages when you validate your projects.">Common validation errors and solutions</a></div>
</div>
</div>

</body>
</html>