<?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, 2008 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, 2008" />
<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="WS-I compliance preferences" />
<meta name="abstract" content="The Service policies preferences page allows you to select your level of compliance with the WS-I Simple SOAP Binding Profile (SSBP) and WS-I Attachement Profile (AP). They can be found on the Service Policies preferences page." />
<meta name="description" content="The Service policies preferences page allows you to select your level of compliance with the WS-I Simple SOAP Binding Profile (SSBP) and WS-I Attachement Profile (AP). They can be found on the Service Policies preferences page." />
<meta content="preferences, Web services, WS-I" name="DC.subject" />
<meta content="preferences, Web services, WS-I" name="keywords" />
<meta scheme="URI" name="DC.Relation" content="../tasks/twspref.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="servicepoliciespreferences" 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>WS-I compliance preferences</title>
</head>
<body id="servicepoliciespreferences"><a name="servicepoliciespreferences"><!-- --></a>


<h1 class="topictitle1">WS-I compliance preferences</h1>



<div><p>The Service policies preferences page allows you to select your
level of compliance with the WS-I Simple SOAP Binding Profile (SSBP) and WS-I
Attachement Profile (AP). They can be found on the Service Policies preferences
page.</p>

<div class="section"><h4 class="sectiontitle">Setting WS-I preferences</h4><p>WS-I Basic Profile is a
outline of requirements to which WSDL and Web service protocol (SOAP/HTTP)
traffic must comply in order to claim WS-I conformance. The Web services WS-I
validation tools currently support WS-I Simple SOAP Binding Profile 1.0 (WS-I
SSBP) which builds on the WS-I Basic Profile, and the WS-I Attachments Profile
1.0 (WS-I AP). To view the specifications, refer to the WS-I Web site, and
under  <span class="uicontrol">Deliverables</span> select  <span class="uicontrol">Basic Profile</span>.</p>
<p>For
more information on WS-I, refer to: <a href="http://www.ws-i.org/" target="_blank">http://www.ws-i.org/</a></p>
<p>WS-I
preferences can be set at the workspace level by opening the Preferences notebook,
or at the project level by right-clicking on a project and selecting Preferences.</p>
<p>You
can select the WS-I AP 1.0 or WS-I BP 1.1 + SSBP 1.0 profiles and choose for
the Web services tools to ignore, suggest, or require compliance. Suggest
will generate a warning if you attempt to generate non-compliant code, whereas
require will prevent you from generating non-compliant code.</p>
<div class="note"><span class="notetitle">Note:</span> If you
change the level of WS-I compliance while WS-I incompliances are listed in
the Task view, the Task view will not be automatically updated. The workspace
must be revalidated before the warnings will be removed from the Task view.</div>
</div>

</div>

<div>
<div class="familylinks">
<div class="parentlink"><strong>Parent topic:</strong> <a href="../tasks/twspref.html" title="Before you begin developing Web services or clients, you can optimize the workbench for Web services development by setting a variety of preferences.">Setting Web services preferences</a></div>
</div>
</div>

</body>
</html>