Moving 1.x branches

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@835145 13f79535-47bb-0310-9956-ffa450edef68

51 files changed, 7820 insertions, 0 deletions

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/LICENSE b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/LICENSE
new file mode 100644
index 0000000000..8aa906c321
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/LICENSE
@@ -0,0 +1,205 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+
+
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/NOTICE b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/NOTICE
new file mode 100644
index 0000000000..25bb89c9b2
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/NOTICE
@@ -0,0 +1,6 @@
+${pom.name}
+Copyright (c) 2005 - 2009 The Apache Software Foundation
+
+This product includes software developed by
+The Apache Software Foundation (http://www.apache.org/).
+
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/pom.xml b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/pom.xml
new file mode 100644
index 0000000000..0a272c2b23
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/pom.xml
@@ -0,0 +1,141 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    * Licensed to the Apache Software Foundation (ASF) under one
+    * or more contributor license agreements.  See the NOTICE file
+    * distributed with this work for additional information
+    * regarding copyright ownership.  The ASF licenses this file
+    * to you under the Apache License, Version 2.0 (the
+    * "License"); you may not use this file except in compliance
+    * with the License.  You may obtain a copy of the License at
+    * 
+    *   http://www.apache.org/licenses/LICENSE-2.0
+    * 
+    * Unless required by applicable law or agreed to in writing,
+    * software distributed under the License is distributed on an
+    * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    * KIND, either express or implied.  See the License for the
+    * specific language governing permissions and limitations
+    * under the License.    
+-->
+<project>
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.apache.tuscany.sca</groupId>
+        <artifactId>tuscany-modules</artifactId>
+        <version>1.5.1-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>tuscany-assembly-xml</artifactId>
+    <name>Apache Tuscany SCA XML Assembly Model</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-assembly</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+        </dependency>
+                
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-definitions</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-policy</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-contribution</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-contribution-namespace</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-contribution-java</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+        </dependency>        
+
+        <dependency>
+            <groupId>javax.xml.stream</groupId>
+            <artifactId>stax-api</artifactId>
+            <version>1.0-2</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.codehaus.woodstox</groupId>
+            <artifactId>wstx-asl</artifactId>
+            <version>3.2.4</version>
+            <scope>runtime</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>stax</groupId>
+                    <artifactId>stax-api</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-definitions-xml</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-policy-xml</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+            <scope>test</scope>
+        </dependency>
+		
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-policy-xml-ws</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+            <scope>test</scope>
+        </dependency>
+       
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-assembly-xsd</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+            <scope>test</scope>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-contribution-impl</artifactId>
+            <version>1.5.1-SNAPSHOT</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-bundle-plugin</artifactId>
+
+                <configuration>
+                    <instructions>
+                        <Bundle-Version>${tuscany.version}</Bundle-Version>
+                        <Bundle-SymbolicName>org.apache.tuscany.sca.assembly.xml</Bundle-SymbolicName>
+                        <Bundle-Description>${pom.name}</Bundle-Description>
+                        <Export-Package>org.apache.tuscany.sca.assembly.xml*</Export-Package>
+                    </instructions>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/BaseAssemblyProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/BaseAssemblyProcessor.java
new file mode 100644
index 0000000000..b76b755dc7
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/BaseAssemblyProcessor.java
@@ -0,0 +1,915 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static javax.xml.XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI;
+import static javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+
+import javax.xml.namespace.QName;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.transform.dom.DOMSource;
+
+import org.apache.tuscany.sca.assembly.AbstractContract;
+import org.apache.tuscany.sca.assembly.AbstractProperty;
+import org.apache.tuscany.sca.assembly.AbstractReference;
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Base;
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.ComponentService;
+import org.apache.tuscany.sca.assembly.ComponentType;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.ConfiguredOperation;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.assembly.Contract;
+import org.apache.tuscany.sca.assembly.Extensible;
+import org.apache.tuscany.sca.assembly.ExtensionFactory;
+import org.apache.tuscany.sca.assembly.Implementation;
+import org.apache.tuscany.sca.assembly.Multiplicity;
+import org.apache.tuscany.sca.assembly.OperationsConfigurator;
+import org.apache.tuscany.sca.assembly.Reference;
+import org.apache.tuscany.sca.assembly.Service;
+import org.apache.tuscany.sca.contribution.ContributionFactory;
+import org.apache.tuscany.sca.contribution.processor.BaseStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXAttributeProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.monitor.Problem;
+import org.apache.tuscany.sca.monitor.Problem.Severity;
+import org.apache.tuscany.sca.monitor.impl.ProblemImpl;
+import org.apache.tuscany.sca.policy.Intent;
+import org.apache.tuscany.sca.policy.IntentAttachPoint;
+import org.apache.tuscany.sca.policy.IntentAttachPointType;
+import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+import org.apache.tuscany.sca.policy.impl.IntentAttachPointTypeFactoryImpl;
+import org.apache.tuscany.sca.policy.util.PolicyValidationException;
+import org.apache.tuscany.sca.policy.util.PolicyValidationUtils;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ * A base class with utility methods for the other artifact processors in this module.
+ *
+ * @version $Rev$ $Date$
+ */
+abstract class BaseAssemblyProcessor extends BaseStAXArtifactProcessor implements Constants {
+
+    protected ContributionFactory contributionFactory;
+    protected AssemblyFactory assemblyFactory;
+    protected ExtensionFactory extensionFactory;
+    protected PolicyFactory policyFactory;
+    protected StAXArtifactProcessor<Object> extensionProcessor;
+    protected StAXAttributeProcessor<Object> extensionAttributeProcessor;
+    protected PolicyAttachPointProcessor policyProcessor;
+    private DocumentBuilderFactory documentBuilderFactory;
+    protected IntentAttachPointTypeFactory intentAttachPointTypeFactory;
+    private Monitor monitor;
+
+
+    /**
+     * Constructs a new BaseArtifactProcessor.
+     * @param contribFactory
+     * @param assemblyFactory
+     * @param extensionFactory
+     * @param policyFactory
+     * @param extensionProcessor
+     * @param monitor
+     */
+    @SuppressWarnings("unchecked")
+    public BaseAssemblyProcessor(ContributionFactory contribFactory,
+                                 AssemblyFactory assemblyFactory,
+                                 ExtensionFactory extensionFactory,
+                                 PolicyFactory policyFactory,
+                                 StAXArtifactProcessor extensionProcessor,
+                                 StAXAttributeProcessor extensionAttributeProcessor,
+                                 Monitor monitor) {
+    	this.contributionFactory = contribFactory;
+    	this.assemblyFactory = assemblyFactory;
+        this.extensionFactory = extensionFactory;
+        this.policyFactory = policyFactory;
+        this.extensionProcessor = (StAXArtifactProcessor<Object>)extensionProcessor;
+        this.extensionAttributeProcessor = extensionAttributeProcessor;
+        this.policyProcessor = new PolicyAttachPointProcessor(policyFactory);
+        this.intentAttachPointTypeFactory = new IntentAttachPointTypeFactoryImpl();
+        this.monitor = monitor;
+    }
+
+    /**
+     * Constructs a new BaseArtifactProcessor.
+     * @param assemblyfactory
+     * @param extensionFactory
+     * @param policyFactory
+     * @param extensionProcessor
+     * @param monitor
+     */
+    @SuppressWarnings("unchecked")
+    public BaseAssemblyProcessor(AssemblyFactory assemblyfactory,
+    				 ExtensionFactory extensionFactory,
+                                 PolicyFactory policyFactory,
+                                 StAXArtifactProcessor extensionProcessor,
+                                 StAXAttributeProcessor extensionAttributeProcessor,
+                                 Monitor monitor) {
+        this.assemblyFactory = assemblyfactory;
+        this.extensionFactory = extensionFactory;
+        this.policyFactory = policyFactory;
+        this.extensionProcessor = (StAXArtifactProcessor<Object>)extensionProcessor;
+        this.extensionAttributeProcessor = extensionAttributeProcessor;
+        this.policyProcessor = new PolicyAttachPointProcessor(policyFactory);
+        this.monitor = monitor;
+    }
+
+    /**
+     * Marshals warnings into the monitor
+     *
+     * @param message
+     * @param model
+     * @param messageParameters
+     */
+    protected void warning(String message, Object model, String... messageParameters) {
+        if (monitor != null){
+            Problem problem = new ProblemImpl(this.getClass().getName(), "assembly-xml-validation-messages", Severity.WARNING, model, message, (Object[])messageParameters);
+            monitor.problem(problem);
+        }
+    }
+
+    /**
+     * Marshals errors into the monitor
+     *
+     * @param problems
+     * @param message
+     * @param model
+     */
+    protected void error(String message, Object model, Object... messageParameters) {
+    	if (monitor != null) {
+	        Problem problem = new ProblemImpl(this.getClass().getName(), "assembly-xml-validation-messages", Severity.ERROR, model, message, (Object[])messageParameters);
+	        monitor.problem(problem);
+    	}
+    }
+
+    /**
+     * Marshals exceptions into the monitor
+     *
+     * @param problems
+     * @param message
+     * @param model
+     */
+    protected void error(String message, Object model, Exception ex) {
+    	if (monitor != null) {
+	        Problem problem = new ProblemImpl(this.getClass().getName(), "assembly-xml-validation-messages", Severity.ERROR, model, message, ex);
+	        monitor.problem(problem);
+    	}
+    }
+
+    /**
+     * Start an element.
+     * @param writer
+     * @param name
+     * @param attrs
+     * @throws XMLStreamException
+     */
+    protected void writeStart(XMLStreamWriter writer, String name, XAttr... attrs) throws XMLStreamException {
+        writeStart(writer, SCA10_NS, name, attrs);
+    }
+
+    /**
+     * Start a document.
+     * @param writer
+     * @throws XMLStreamException
+     */
+    protected void writeStartDocument(XMLStreamWriter writer, String name, XAttr... attrs) throws XMLStreamException {
+        writer.writeStartDocument();
+        writer.setDefaultNamespace(SCA10_NS);
+        writeStart(writer, SCA10_NS, name, attrs);
+        writer.writeDefaultNamespace(SCA10_NS);
+    }
+
+    /**
+     * Read list of reference targets
+     * @param reference
+     * @param reader
+     */
+    protected void readTargets(Reference reference, XMLStreamReader reader) {
+        String value = reader.getAttributeValue(null, TARGET);
+        ComponentService target = null;
+        if (value != null) {
+            for (StringTokenizer tokens = new StringTokenizer(value); tokens.hasMoreTokens();) {
+                target = assemblyFactory.createComponentService();
+                target.setUnresolved(true);
+                target.setName(tokens.nextToken());
+                reference.getTargets().add(target);
+            }
+        }
+    }
+
+    /**
+     * Write a list of targets into an attribute
+     * @param reference
+     * @return
+     */
+    protected XAttr writeTargets(Reference reference) {
+        List<String> targets = new ArrayList<String>();
+        for (Service target : reference.getTargets()) {
+            targets.add(target.getName());
+        }
+        return new XAttr(TARGET, targets);
+    }
+
+    /**
+     * Read a multiplicity attribute.
+     * @param reference
+     * @param reader
+     */
+    protected void readMultiplicity(AbstractReference reference, XMLStreamReader reader) {
+        String value = reader.getAttributeValue(null, MULTIPLICITY);
+        if (ZERO_ONE.equals(value)) {
+            reference.setMultiplicity(Multiplicity.ZERO_ONE);
+        } else if (ONE_N.equals(value)) {
+            reference.setMultiplicity(Multiplicity.ONE_N);
+        } else if (ZERO_N.equals(value)) {
+            reference.setMultiplicity(Multiplicity.ZERO_N);
+        } else if (ONE_ONE.equals(value)) {
+            reference.setMultiplicity(Multiplicity.ONE_ONE);
+        }
+    }
+
+    protected XAttr writeMultiplicity(AbstractReference reference) {
+        Multiplicity multiplicity = reference.getMultiplicity();
+        if (multiplicity != null) {
+            String value = null;
+            if (Multiplicity.ZERO_ONE.equals(multiplicity)) {
+                value = ZERO_ONE;
+            } else if (Multiplicity.ONE_N.equals(multiplicity)) {
+                value = ONE_N;
+            } else if (Multiplicity.ZERO_N.equals(multiplicity)) {
+                value = ZERO_N;
+            } else if (Multiplicity.ONE_ONE.equals(multiplicity)) {
+                value = ONE_ONE;
+                return null;
+            }
+            return new XAttr(MULTIPLICITY, value);
+        }
+        return null;
+    }
+
+    /**
+     * Returns the value of a constrainingType attribute.
+     * @param reader
+     * @return
+     */
+    protected ConstrainingType readConstrainingType(XMLStreamReader reader) {
+        QName constrainingTypeName = getQName(reader, Constants.CONSTRAINING_TYPE);
+        if (constrainingTypeName != null) {
+            ConstrainingType constrainingType = assemblyFactory.createConstrainingType();
+            constrainingType.setName(constrainingTypeName);
+            constrainingType.setUnresolved(true);
+            return constrainingType;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Reads an abstract property element.
+     * @param property
+     * @param reader
+     * @throws XMLStreamException
+     * @throws ContributionReadException
+     */
+    protected void readAbstractProperty(AbstractProperty property, XMLStreamReader reader) throws XMLStreamException,
+        ContributionReadException {
+
+        property.setName(getString(reader, NAME));
+        property.setMany(getBoolean(reader, MANY));
+        property.setMustSupply(getBoolean(reader, MUST_SUPPLY));
+        property.setXSDElement(getQName(reader, ELEMENT));
+        property.setXSDType(getQName(reader, TYPE));
+    }
+
+    /**
+     * Resolve an implementation.
+     * @param implementation
+     * @param resolver
+     * @return
+     * @throws ContributionResolveException
+     */
+    protected Implementation resolveImplementation(Implementation implementation, ModelResolver resolver)
+        throws ContributionResolveException, PolicyValidationException {
+        if (implementation != null) {
+            if (implementation.isUnresolved()) {
+                implementation = resolver.resolveModel(Implementation.class, implementation);
+
+                // Lazily resolve implementations
+                if (implementation.isUnresolved()) {
+                    extensionProcessor.resolve(implementation, resolver);
+                    if (!implementation.isUnresolved()) {
+                        //resolve policies
+                        if ( implementation instanceof PolicySetAttachPoint ) {
+                            PolicySetAttachPoint policiedImpl = (PolicySetAttachPoint)implementation;
+                            resolveIntents(policiedImpl.getRequiredIntents(), resolver);
+                            PolicyValidationUtils.validateIntents(policiedImpl, policiedImpl.getType());
+
+                            resolvePolicySets(policiedImpl.getPolicySets(), resolver);
+                            PolicyValidationUtils.validatePolicySets(policiedImpl);
+
+                            if ( implementation instanceof OperationsConfigurator ) {
+                                OperationsConfigurator opsConfigurator = (OperationsConfigurator)implementation;
+                                for ( ConfiguredOperation implOp : opsConfigurator.getConfiguredOperations() ) {
+                                    resolveIntents(implOp.getRequiredIntents(), resolver);
+                                    PolicyValidationUtils.validateIntents(implOp, policiedImpl.getType());
+
+                                    resolvePolicySets(implOp.getPolicySets(), resolver);
+                                    PolicyValidationUtils.validatePolicySets(implOp,
+                                                                             policiedImpl.getType(),
+                                                                             policiedImpl.getApplicablePolicySets());
+                                }
+                            }
+
+                            for ( Service service : implementation.getServices() ) {
+                                resolveIntents(service.getRequiredIntents(), resolver);
+                                resolvePolicySets(service.getPolicySets(), resolver);
+
+                                for ( ConfiguredOperation svcOp : service.getConfiguredOperations() ) {
+                                    resolveIntents(svcOp.getRequiredIntents(), resolver);
+                                    resolvePolicySets(svcOp.getPolicySets(), resolver);
+                                }
+                            }
+
+                            for ( Reference reference : implementation.getReferences() ) {
+                                resolveIntents(reference.getRequiredIntents(), resolver);
+                                resolvePolicySets(reference.getPolicySets(), resolver);
+                            }
+                        }
+
+                        resolver.addModel(implementation);
+                    }
+                }
+            }
+
+            if ( implementation instanceof IntentAttachPoint &&
+                ((IntentAttachPoint)implementation).getType() != null &&
+                ((IntentAttachPoint)implementation).getType().isUnresolved() ) {
+                ((IntentAttachPoint)implementation).setType(
+                               resolver.resolveModel(IntentAttachPointType.class,
+                                                     ((IntentAttachPoint)implementation).getType()));
+            }
+        }
+        return implementation;
+    }
+
+    /**
+     * Resolve interface, callback interface and bindings on a list of contracts.
+     * @param contracts the list of contracts
+     * @param resolver the resolver to use to resolve models
+     */
+    protected <C extends Contract> void resolveContracts(List<C> contracts, ModelResolver resolver)
+    throws ContributionResolveException {
+        resolveContracts(null, contracts, resolver);
+    }
+
+
+    /**
+     * Resolve interface, callback interface and bindings on a list of contracts.
+     * @param parent element for the contracts
+     * @param contracts the list of contracts
+     * @param resolver the resolver to use to resolve models
+     */
+    protected <C extends Contract> void resolveContracts(Base parent, List<C> contracts, ModelResolver resolver)
+        throws ContributionResolveException {
+
+        String parentName = (parent instanceof Composite) ? ((Composite)parent).getName().toString() :
+            (parent instanceof Component) ? ((Component)parent).getName() : "UNKNOWN";
+
+        for (Contract contract : contracts) {
+            try {
+                //resolve the intents and policysets as they need to be copied over into the
+                //child binding elements
+                resolveIntents(contract.getRequiredIntents(), resolver);
+                resolvePolicySets(contract.getPolicySets(), resolver);
+                resolvePolicySets(contract.getApplicablePolicySets(), resolver);
+
+                // Inherit the composite / component level applicable policy sets.
+                if ( parent != null && parent instanceof PolicySetAttachPoint )  {
+                    addInheritedPolicySets(((PolicySetAttachPoint)parent).getApplicablePolicySets(), contract.getApplicablePolicySets());
+                }
+
+                for ( ConfiguredOperation confOp : contract.getConfiguredOperations() ) {
+                    resolveIntents(confOp.getRequiredIntents(), resolver);
+                    resolvePolicySets(confOp.getPolicySets(), resolver);
+                    resolvePolicySets(confOp.getApplicablePolicySets(), resolver);
+
+                    //inherit applicable policy sets from parent contract
+                    addInheritedPolicySets(contract.getApplicablePolicySets(), confOp.getApplicablePolicySets());
+                }
+
+                // Resolve the interface contract
+                InterfaceContract interfaceContract = contract.getInterfaceContract();
+                if (interfaceContract != null) {
+                    extensionProcessor.resolve(interfaceContract, resolver);
+                }
+
+                // Resolve bindings
+                for (int i = 0, n = contract.getBindings().size(); i < n; i++) {
+                    Binding binding = contract.getBindings().get(i);
+                    extensionProcessor.resolve(binding, resolver);
+
+                    if (binding instanceof IntentAttachPoint) {
+                        IntentAttachPoint policiedBinding = (IntentAttachPoint)binding;
+
+                        if ( policiedBinding.getType() != null && policiedBinding.getType().isUnresolved() ) {
+                            IntentAttachPointType resolved =
+                                resolver.resolveModel(IntentAttachPointType.class,
+                                                      policiedBinding.getType());
+                            policiedBinding.setType(resolved);
+                        }
+
+                        resolveIntents(policiedBinding.getRequiredIntents(), resolver);
+                        PolicyValidationUtils.validateIntents(policiedBinding, policiedBinding.getType());
+                    }
+
+                    if (binding instanceof PolicySetAttachPoint) {
+                        PolicySetAttachPoint policiedBinding = (PolicySetAttachPoint)binding;
+                        resolvePolicySets(policiedBinding.getPolicySets(), resolver);
+                        //validate if attached policysets apply to the binding
+                        resolvePolicySets(policiedBinding.getApplicablePolicySets(), resolver);
+                        //inherit the applicable policysets from parent contract as whatever applies to that
+                        //applies to the binding as well
+                        addInheritedPolicySets(contract.getApplicablePolicySets(), policiedBinding.getApplicablePolicySets());
+                        PolicyValidationUtils.validatePolicySets(policiedBinding);
+                    }
+
+                    if (binding instanceof OperationsConfigurator) {
+                        OperationsConfigurator opConfigurator = (OperationsConfigurator)binding;
+                        for (ConfiguredOperation confOp : opConfigurator.getConfiguredOperations()) {
+                            resolveIntents(confOp.getRequiredIntents(), resolver);
+                            PolicyValidationUtils.validateIntents(confOp, ((PolicySetAttachPoint)binding).getType());
+
+                            resolvePolicySets(confOp.getPolicySets(), resolver);
+                            resolvePolicySets(confOp.getApplicablePolicySets(), resolver);
+                            //inherit the applicable policysets from parent binding as whatever applies to that
+                            //applies to the binding as well
+                            addInheritedPolicySets(((PolicySetAttachPoint)binding).getApplicablePolicySets(),
+                                                   confOp.getApplicablePolicySets());
+                            PolicyValidationUtils.validatePolicySets(confOp, ((PolicySetAttachPoint)binding).getType());
+                        }
+                    }
+                }
+
+                // Resolve callback bindings
+                if (contract.getCallback() != null) {
+                    resolveIntents(contract.getCallback().getRequiredIntents(), resolver);
+                    resolvePolicySets(contract.getCallback().getPolicySets(), resolver);
+                    resolvePolicySets(contract.getCallback().getApplicablePolicySets(), resolver);
+                    //inherit the contract's policy intents and policysets
+                    addInheritedPolicySets(contract.getApplicablePolicySets(), contract.getCallback().getApplicablePolicySets());
+
+                    for (int i = 0, n = contract.getCallback().getBindings().size(); i < n; i++) {
+                        Binding binding = contract.getCallback().getBindings().get(i);
+                        extensionProcessor.resolve(binding, resolver);
+
+                        if (binding instanceof IntentAttachPoint) {
+                            IntentAttachPoint policiedBinding = (IntentAttachPoint)binding;
+
+                            if ( policiedBinding.getType().isUnresolved() ) {
+                                IntentAttachPointType resolved =
+                                    resolver.resolveModel(IntentAttachPointType.class,
+                                                          policiedBinding.getType());
+                                policiedBinding.setType(resolved);
+                            }
+
+                            resolveIntents(policiedBinding.getRequiredIntents(), resolver);
+                            PolicyValidationUtils.validateIntents(policiedBinding, policiedBinding.getType());
+                        }
+
+                        if (binding instanceof PolicySetAttachPoint) {
+                            PolicySetAttachPoint policiedBinding = (PolicySetAttachPoint)binding;
+                            resolvePolicySets(policiedBinding.getPolicySets(), resolver);
+                            //validate if attached policysets apply to the binding
+                            resolvePolicySets(policiedBinding.getApplicablePolicySets(), resolver);
+                            //inherit the applicable policysets from parent contract as whatever applies to that
+                            //applies to the binding as well
+                            addInheritedPolicySets(contract.getApplicablePolicySets(), policiedBinding.getApplicablePolicySets());
+                            PolicyValidationUtils.validatePolicySets(policiedBinding);
+                        }
+
+                        if (binding instanceof OperationsConfigurator) {
+                            OperationsConfigurator opConfigurator = (OperationsConfigurator)binding;
+                            for (ConfiguredOperation confOp : opConfigurator.getConfiguredOperations()) {
+                                resolveIntents(confOp.getRequiredIntents(), resolver);
+                                PolicyValidationUtils.validateIntents(confOp, ((PolicySetAttachPoint)binding).getType());
+
+                                resolvePolicySets(confOp.getPolicySets(), resolver);
+                                resolvePolicySets(confOp.getApplicablePolicySets(), resolver);
+                                //inherit the applicable policysets from parent binding as whatever applies to that
+                                //applies to the binding as well
+                                addInheritedPolicySets(((PolicySetAttachPoint)binding).getApplicablePolicySets(),
+                                                       confOp.getApplicablePolicySets());
+                                PolicyValidationUtils.validatePolicySets(confOp, ((PolicySetAttachPoint)binding).getType());
+                            }
+                        }
+                    }
+                }
+            } catch ( PolicyValidationException e ) {
+            	error("PolicyServiceValidationException", contract, contract.getName(), parentName, e.getMessage());
+                //throw new ContributionResolveException("PolicyValidation exceptions when processing service/reference '"
+                                                       //+ contract.getName() + "' in '" + parentName + "'");
+            }
+        }
+    }
+
+    /**
+     * Resolve interface and callback interface on a list of abstract contracts.
+     * @param contracts the list of contracts
+     * @param resolver the resolver to use to resolve models
+     */
+    protected <C extends AbstractContract> void resolveAbstractContracts(List<C> contracts, ModelResolver resolver)
+        throws ContributionResolveException {
+        for (AbstractContract contract : contracts) {
+
+            // Resolve the interface contract
+            InterfaceContract interfaceContract = contract.getInterfaceContract();
+            if (interfaceContract != null) {
+                extensionProcessor.resolve(interfaceContract, resolver);
+            }
+        }
+    }
+
+    /**
+     * Returns a constrainingType attribute.
+     * @param componentType
+     * @return
+     */
+    protected XAttr writeConstrainingType(ComponentType componentType) {
+        ConstrainingType constrainingType = componentType.getConstrainingType();
+        if (constrainingType != null)
+            return new XAttr(Constants.CONSTRAINING_TYPE, constrainingType.getName());
+        else
+            return null;
+    }
+
+    /**
+     * Read a property value into a DOM document.
+     * @param element
+     * @param type
+     * @param reader
+     * @return
+     * @throws XMLStreamException
+     * @throws ContributionReadException
+     * @throws ParserConfigurationException
+     */
+    protected Document readPropertyValue(QName element, QName type, XMLStreamReader reader) throws XMLStreamException,
+        ContributionReadException {
+
+        Document document;
+        try {
+            if (documentBuilderFactory == null) {
+                documentBuilderFactory = DocumentBuilderFactory.newInstance();
+                documentBuilderFactory.setNamespaceAware(true);
+            }
+            document = documentBuilderFactory.newDocumentBuilder().newDocument();
+        } catch (ParserConfigurationException e) {
+        	ContributionReadException ce = new ContributionReadException(e);
+        	error("ContributionReadException", documentBuilderFactory, ce);
+            throw ce;
+        }
+
+        // root element has no namespace and local name "value"
+        Element root = document.createElementNS(null, "value");
+        if (type != null) {
+            org.w3c.dom.Attr xsi = document.createAttributeNS(XMLNS_ATTRIBUTE_NS_URI, "xmlns:xsi");
+            xsi.setValue(W3C_XML_SCHEMA_INSTANCE_NS_URI);
+            root.setAttributeNodeNS(xsi);
+
+            String prefix = type.getPrefix();
+            if (prefix == null || prefix.length() == 0) {
+                prefix = "ns";
+            }
+
+            declareNamespace(root, prefix, type.getNamespaceURI());
+
+            org.w3c.dom.Attr xsiType = document.createAttributeNS(W3C_XML_SCHEMA_INSTANCE_NS_URI, "xsi:type");
+            xsiType.setValue(prefix + ":" + type.getLocalPart());
+            root.setAttributeNodeNS(xsiType);
+        }
+        document.appendChild(root);
+
+        loadElement(reader, root);
+        return document;
+    }
+
+    /**
+     * Create a DOM element
+     * @param document
+     * @param name
+     * @return
+     */
+    private Element createElement(Document document, QName name) {
+        String prefix = name.getPrefix();
+        String qname =
+            (prefix != null && prefix.length() > 0) ? prefix + ":" + name.getLocalPart() : name.getLocalPart();
+        return document.createElementNS(name.getNamespaceURI(), qname);
+    }
+
+    /**
+     * Declare a namespace.
+     * @param element
+     * @param prefix
+     * @param ns
+     */
+    private void declareNamespace(Element element, String prefix, String ns) {
+        if (ns == null) {
+            ns = "";
+        }
+        if (prefix == null) {
+            prefix = "";
+        }
+        String qname = null;
+        if ("".equals(prefix)) {
+            qname = "xmlns";
+        } else {
+            qname = "xmlns:" + prefix;
+        }
+        Node node = element;
+        boolean declared = false;
+        while (node != null && node.getNodeType() == Node.ELEMENT_NODE) {
+            NamedNodeMap attrs = node.getAttributes();
+            if (attrs == null) {
+                break;
+            }
+            Node attr = attrs.getNamedItem(qname);
+            if (attr != null) {
+                declared = ns.equals(attr.getNodeValue());
+                break;
+            }
+            node = node.getParentNode();
+        }
+        if (!declared) {
+            org.w3c.dom.Attr attr = element.getOwnerDocument().createAttributeNS(XMLNS_ATTRIBUTE_NS_URI, qname);
+            attr.setValue(ns);
+            element.setAttributeNodeNS(attr);
+        }
+    }
+
+    /**
+     * Load a property value specification from an StAX stream into a DOM
+     * Document. Only elements, text and attributes are processed; all comments
+     * and other whitespace are ignored.
+     *
+     * @param reader the stream to read from
+     * @param root the DOM node to load
+     * @throws javax.xml.stream.XMLStreamException
+     */
+    private void loadElement(XMLStreamReader reader, Element root) throws XMLStreamException {
+        Document document = root.getOwnerDocument();
+        Node current = root;
+        while (true) {
+            switch (reader.next()) {
+                case XMLStreamConstants.START_ELEMENT:
+                    QName name = reader.getName();
+                    Element child = createElement(document, name);
+
+                    // push the new element and make it the current one
+                    current.appendChild(child);
+                    current = child;
+
+                    int count = reader.getNamespaceCount();
+                    for (int i = 0; i < count; i++) {
+                        String prefix = reader.getNamespacePrefix(i);
+                        String ns = reader.getNamespaceURI(i);
+                        declareNamespace(child, prefix, ns);
+                    }
+
+                    if (!"".equals(name.getNamespaceURI())) {
+                        declareNamespace(child, name.getPrefix(), name.getNamespaceURI());
+                    }
+
+                    // add the attributes for this element
+                    count = reader.getAttributeCount();
+                    for (int i = 0; i < count; i++) {
+                        String ns = reader.getAttributeNamespace(i);
+                        String prefix = reader.getAttributePrefix(i);
+                        String qname = reader.getAttributeLocalName(i);
+                        String value = reader.getAttributeValue(i);
+                        if (prefix != null && prefix.length() != 0) {
+                            qname = prefix + ":" + qname;
+                        }
+                        child.setAttributeNS(ns, qname, value);
+                        if (ns != null) {
+                            declareNamespace(child, prefix, ns);
+                        }
+                    }
+
+                    break;
+                case XMLStreamConstants.CDATA:
+                    current.appendChild(document.createCDATASection(reader.getText()));
+                    break;
+                case XMLStreamConstants.CHARACTERS:
+                    current.appendChild(document.createTextNode(reader.getText()));
+                    break;
+                case XMLStreamConstants.END_ELEMENT:
+                    // if we are back at the root then we are done
+                    if (current == root) {
+                        return;
+                    }
+
+                    // pop the element off the stack
+                    current = current.getParentNode();
+            }
+        }
+    }
+
+    /**
+     * Resolve policy intents attached to a specific SCA Artifact
+     * @param policyIntents list of policy intents
+     * @param resolver
+     */
+    protected void resolveIntents(List<Intent> policyIntents, ModelResolver resolver) {
+        List<Intent> requiredIntents = new ArrayList<Intent>();
+        Intent resolvedIntent = null;
+        for (Intent intent : policyIntents) {
+            resolvedIntent = resolver.resolveModel(Intent.class, intent);
+            requiredIntents.add(resolvedIntent);
+        }
+        policyIntents.clear();
+        policyIntents.addAll(requiredIntents);
+    }
+
+    /**
+     * Resolve policy sets attached to a specific SCA Construct
+     * @param policySets list of attached policy sets
+     * @param resolver
+     */
+    protected void resolvePolicySets(List<PolicySet> policySets, ModelResolver resolver) {
+        List<PolicySet> resolvedPolicySets = new ArrayList<PolicySet>();
+        PolicySet resolvedPolicySet = null;
+        for (PolicySet policySet : policySets) {
+            if (policySet.isUnresolved()) {
+                resolvedPolicySet = resolver.resolveModel(PolicySet.class, policySet);
+                resolvedPolicySets.add(resolvedPolicySet);
+            } else {
+                resolvedPolicySets.add(policySet);
+            }
+        }
+        policySets.clear();
+        policySets.addAll(resolvedPolicySets);
+    }
+
+    /**
+     * Write the value of a property
+     * @param document
+     * @param element
+     * @param type
+     * @param writer
+     * @throws XMLStreamException
+     */
+    protected void writePropertyValue(Object propertyValue, QName element, QName type, XMLStreamWriter writer)
+        throws XMLStreamException {
+
+        if (propertyValue instanceof Document) {
+            Document document = (Document)propertyValue;
+            NodeList nodeList = document.getDocumentElement().getChildNodes();
+
+            for (int item = 0; item < nodeList.getLength(); ++item) {
+                Node node = nodeList.item(item);
+                int nodeType = node.getNodeType();
+                if (nodeType == Node.ELEMENT_NODE) {
+                    XMLStreamReader reader =
+                        XMLInputFactory.newInstance().createXMLStreamReader(new DOMSource(node));
+
+                    while (reader.hasNext()) {
+                        switch (reader.next()) {
+                            case XMLStreamConstants.START_ELEMENT:
+                                QName name = reader.getName();
+                                writer.writeStartElement(name.getPrefix(), name.getLocalPart(), name.getNamespaceURI());
+
+                                int namespaces = reader.getNamespaceCount();
+                                for (int i = 0; i < namespaces; i++) {
+                                    String prefix = reader.getNamespacePrefix(i);
+                                    String ns = reader.getNamespaceURI(i);
+                                    writer.writeNamespace(prefix, ns);
+                                }
+
+                                if (!"".equals(name.getNamespaceURI())) {
+                                    writer.writeNamespace(name.getPrefix(), name.getNamespaceURI());
+                                }
+
+                                // add the attributes for this element
+                                namespaces = reader.getAttributeCount();
+                                for (int i = 0; i < namespaces; i++) {
+                                    String ns = reader.getAttributeNamespace(i);
+                                    String prefix = reader.getAttributePrefix(i);
+                                    String qname = reader.getAttributeLocalName(i);
+                                    String value = reader.getAttributeValue(i);
+
+                                    writer.writeAttribute(prefix, ns, qname, value);
+                                }
+
+                                break;
+                            case XMLStreamConstants.CDATA:
+                                writer.writeCData(reader.getText());
+                                break;
+                            case XMLStreamConstants.CHARACTERS:
+                                writer.writeCharacters(reader.getText());
+                                break;
+                            case XMLStreamConstants.END_ELEMENT:
+                                writer.writeEndElement();
+                                break;
+                        }
+                    }
+                } else {
+                    writer.writeCharacters(node.getTextContent());
+                }
+            }
+        }
+    }
+
+    protected void addInheritedIntents(List<Intent> sourceList, List<Intent> targetList) {
+        if (sourceList != null) {
+            targetList.addAll(sourceList);
+        }
+    }
+
+    protected  void addInheritedPolicySets(List<PolicySet> sourceList, List<PolicySet> targetList) {
+        if (sourceList != null) {
+            targetList.addAll(sourceList);
+        }
+    }
+
+    /**
+     *
+     * @param reader
+     * @param elementName
+     * @param extensible
+     * @param extensionAttributeProcessor
+     * @throws ContributionReadException
+     * @throws XMLStreamException
+     */
+    protected void readExtendedAttributes(XMLStreamReader reader, Extensible extensible) throws ContributionReadException, XMLStreamException {
+        super.readExtendedAttributes(reader, extensible, extensionAttributeProcessor, extensionFactory);
+    }
+
+
+    /*protected void validatePolicySets(PolicySetAttachPoint policySetAttachPoint)
+                                                            throws ContributionResolveException {
+        validatePolicySets(policySetAttachPoint, policySetAttachPoint.getApplicablePolicySets());
+    }
+
+
+    protected void validatePolicySets(PolicySetAttachPoint policySetAttachPoint,
+                                      List<PolicySet> applicablePolicySets) throws ContributionResolveException {
+        //Since the applicablePolicySets in a policySetAttachPoint will already have the
+        //list of policysets that might ever be applicable to this attachPoint, just check
+        //if the defined policysets feature in the list of applicable policysets
+        IntentAttachPointType attachPointType = policySetAttachPoint.getType();
+        for ( PolicySet definedPolicySet : policySetAttachPoint.getPolicySets() ) {
+            if ( !definedPolicySet.isUnresolved() ) {
+                if ( !applicablePolicySets.contains(definedPolicySet)) {
+                    throw new ContributionResolveException("Policy Set '" + definedPolicySet.getName()
+                                                           + "' does not apply to binding type  "
+                                                           + attachPointType.getName());
+                }
+            } else {
+                throw new ContributionResolveException("Policy Set '" + definedPolicySet.getName()
+                                                       + "' is not defined in this domain  ");
+
+
+            }
+        }
+    }*/
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeDocumentProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeDocumentProcessor.java
new file mode 100644
index 0000000000..7681115149
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeDocumentProcessor.java
@@ -0,0 +1,143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLConnection;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.tuscany.sca.assembly.ComponentType;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.ValidatingXMLInputFactory;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+
+/**
+ * A componentType processor.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ComponentTypeDocumentProcessor extends BaseAssemblyProcessor implements URLArtifactProcessor<ComponentType> {
+    private XMLInputFactory inputFactory;
+    
+    /**
+     * Constructs a new componentType processor.
+     * @param factory
+     * @param policyFactory
+     * @param registry
+     */
+    public ComponentTypeDocumentProcessor(StAXArtifactProcessor staxProcessor, 
+    									  XMLInputFactory inputFactory, 
+    									  Monitor monitor) {
+        super(null, null, null, staxProcessor, null, monitor);
+        this.inputFactory = inputFactory;
+    }
+    
+    /**
+     * Constructs a new componentType processor.
+     * @param modelFactories
+     * @param staxProcessor
+     */
+    public ComponentTypeDocumentProcessor(ModelFactoryExtensionPoint modelFactories, 
+    									  StAXArtifactProcessor staxProcessor,
+    									  Monitor monitor) {
+        super(null, null, null, staxProcessor, null, monitor);
+        this.inputFactory = modelFactories.getFactory(ValidatingXMLInputFactory.class);
+    }
+    
+    public ComponentType read(URL contributionURL, URI uri, URL url) throws ContributionReadException {
+        InputStream urlStream = null;
+        try {
+            
+            // Create a stream reader
+            URLConnection connection = url.openConnection();
+            connection.setUseCaches(false);
+            urlStream = connection.getInputStream();
+            XMLStreamReader reader = inputFactory.createXMLStreamReader(urlStream);
+            reader.nextTag();
+            
+            // Reader the componentType model 
+            ComponentType componentType = (ComponentType)extensionProcessor.read(reader);
+            if (componentType != null) {
+                componentType.setURI(uri.toString());
+            }
+
+            // For debugging purposes, write it back to XML
+//            if (componentType != null) {
+//                try {
+//                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
+//                    XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
+//                    outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
+//                    extensionProcessor.write(componentType, outputFactory.createXMLStreamWriter(bos));
+//                    Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(bos.toByteArray()));
+//                    OutputFormat format = new OutputFormat();
+//                    format.setIndenting(true);
+//                    format.setIndent(2);
+//                    XMLSerializer serializer = new XMLSerializer(System.out, format);
+//                    serializer.serialize(document);
+//                } catch (Exception e) {
+//                    e.printStackTrace();
+//                }
+//            }
+            
+            return componentType;
+            
+        } catch (XMLStreamException e) {
+        	ContributionReadException ce = new ContributionReadException(e);
+        	error("ContributionReadException", inputFactory, ce);
+            throw ce;
+        } catch (IOException e) {
+        	ContributionReadException ce = new ContributionReadException(e);
+        	error("ContributionReadException", inputFactory, ce);
+            throw ce;
+        } finally {
+            try {
+                if (urlStream != null) {
+                    urlStream.close();
+                    urlStream = null;
+                }
+            } catch (IOException ioe) {
+                //ignore
+            }
+        }
+    }
+    
+    public void resolve(ComponentType componentType, ModelResolver resolver) throws ContributionResolveException {
+        extensionProcessor.resolve(componentType, resolver);
+    }
+    
+    public String getArtifactType() {
+        return ".componentType";
+    }
+    
+    public Class<ComponentType> getModelType() {
+        return ComponentType.class;
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeModelResolver.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeModelResolver.java
new file mode 100644
index 0000000000..d0d11cd02b
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeModelResolver.java
@@ -0,0 +1,95 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.tuscany.sca.assembly.ComponentType;
+import org.apache.tuscany.sca.contribution.Contribution;
+import org.apache.tuscany.sca.contribution.Import;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.java.JavaImport;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+
+/**
+ * A Model Resolver for ComponentType models.
+ *
+ * @version $Rev$ $Date$
+ */
+public class ComponentTypeModelResolver implements ModelResolver {
+	private Contribution contribution;
+    private Map<String, ComponentType> map = new HashMap<String, ComponentType>();
+    
+    public ComponentTypeModelResolver(Contribution contribution, ModelFactoryExtensionPoint modelFactories) {
+    	this.contribution = contribution;
+    }
+
+    public void addModel(Object resolved) {
+        ComponentType componentType = (ComponentType)resolved;
+        map.put(componentType.getURI(), componentType);
+    }
+    
+    public Object removeModel(Object resolved) {
+        return map.remove(((ComponentType)resolved).getURI());
+    }
+    
+    public <T> T resolveModel(Class<T> modelClass, T unresolved) {
+
+    	//get componentType artifact URI
+        String uri = ((ComponentType)unresolved).getURI();
+        if (uri == null) {
+        	return (T)unresolved;
+        }
+        
+        //lookup the componentType
+        ComponentType resolved = (ComponentType) map.get(uri);
+        if (resolved != null) {
+            return modelClass.cast(resolved);
+        } 
+        
+        //If not found, delegate the resolution to the imports (in this case based on the java imports)
+        //compute the package name from the componentType URI
+        if (unresolved instanceof ComponentType) {
+            //FIXME The core assembly model now depends on java imports to 
+            // resolve componentTypes of all kinds, this is not right at all!!!
+            int s = uri.lastIndexOf('/');
+            if (s != -1) {
+                String packageName = uri.substring(0, uri.lastIndexOf("/"));
+                for (Import import_ : this.contribution.getImports()) {
+                    if (import_ instanceof JavaImport) {
+                    	JavaImport javaImport = (JavaImport)import_;
+                    	//check the import location against the computed package name from the componentType URI
+                        if (javaImport.getPackage().equals(packageName)) {
+                            // Delegate the resolution to the import resolver
+                            resolved = javaImport.getModelResolver().resolveModel(ComponentType.class, (ComponentType)unresolved);
+                            if (!resolved.isUnresolved()) {
+                                return modelClass.cast(resolved);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return (T)unresolved;
+    }
+    
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeProcessor.java
new file mode 100644
index 0000000000..964116a0c2
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeProcessor.java
@@ -0,0 +1,390 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
+import static javax.xml.stream.XMLStreamConstants.START_ELEMENT;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.assembly.Callback;
+import org.apache.tuscany.sca.assembly.ComponentType;
+import org.apache.tuscany.sca.assembly.Contract;
+import org.apache.tuscany.sca.assembly.Extensible;
+import org.apache.tuscany.sca.assembly.ExtensionFactory;
+import org.apache.tuscany.sca.assembly.Property;
+import org.apache.tuscany.sca.assembly.Reference;
+import org.apache.tuscany.sca.assembly.Service;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXAttributeProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.impl.OperationImpl;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.policy.IntentAttachPoint;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+import org.w3c.dom.Document;
+
+/**
+ * A componentType processor.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ComponentTypeProcessor extends BaseAssemblyProcessor implements StAXArtifactProcessor<ComponentType> {
+    
+    /**
+     * Constructs a new componentType processor.
+     * @param assemblyFactory
+     * @param policyFactory
+     * @param registry
+     */
+    public ComponentTypeProcessor(AssemblyFactory assemblyFactory, 
+    		                      ExtensionFactory extensionFactory,
+    		                      PolicyFactory policyFactory, 
+    				      StAXArtifactProcessor extensionProcessor, 
+    				      StAXAttributeProcessor extensionAttributeProcessor, 
+    				      Monitor monitor) {
+        super(assemblyFactory, extensionFactory, policyFactory, extensionProcessor, extensionAttributeProcessor, monitor);
+    }
+
+    /**
+     * Constructs a new componentType processor.
+     * 
+     * @param modelFactories
+     * @param extensionProcessor
+     */
+    public ComponentTypeProcessor(ModelFactoryExtensionPoint modelFactories, 
+    				  StAXArtifactProcessor extensionProcessor,
+    				  StAXAttributeProcessor extensionAttributeProcessor,
+    				  Monitor monitor) {
+        super(modelFactories.getFactory(AssemblyFactory.class),
+        	  modelFactories.getFactory(ExtensionFactory.class),
+              modelFactories.getFactory(PolicyFactory.class), 
+              extensionProcessor,
+              extensionAttributeProcessor,
+              monitor);
+    }
+    
+    public ComponentType read(XMLStreamReader reader) throws ContributionReadException {
+        ComponentType componentType = null;
+        Service service = null;
+        Reference reference = null;
+        Contract contract = null;
+        Property property = null;
+        Callback callback = null;
+        QName name = null;
+        
+        try {
+            // Read the componentType document
+            while (reader.hasNext()) {
+                int event = reader.getEventType();
+                switch (event) {
+                    case START_ELEMENT:
+                        name = reader.getName();
+    
+                        if (Constants.COMPONENT_TYPE_QNAME.equals(name)) {
+    
+                            // Read a <componentType>
+                            componentType = assemblyFactory.createComponentType();
+                            componentType.setConstrainingType(readConstrainingType(reader));
+    
+                        } else if (Constants.SERVICE_QNAME.equals(name)) {
+    
+                            // Read a <service>
+                            service = assemblyFactory.createService();
+                            contract = service;
+                            service.setName(getString(reader, Constants.NAME));
+                            componentType.getServices().add(service);
+                            policyProcessor.readPolicies(service, reader);
+    
+                        } else if (Constants.REFERENCE_QNAME.equals(name)) {
+    
+                            // Read a <reference>
+                            reference = assemblyFactory.createReference();
+                            contract = reference;
+                            reference.setName(getString(reader, Constants.NAME));
+                            reference.setWiredByImpl(getBoolean(reader, Constants.WIRED_BY_IMPL));
+                            readMultiplicity(reference, reader);
+                            readTargets(reference, reader);
+                            componentType.getReferences().add(reference);
+                            policyProcessor.readPolicies(reference, reader);
+    
+                        } else if (Constants.PROPERTY_QNAME.equals(name)) {
+    
+                            // Read a <property>
+                            property = assemblyFactory.createProperty();
+                            readAbstractProperty(property, reader);
+                            policyProcessor.readPolicies(property, reader);
+                            
+                            // Read the property value
+                            Document value = readPropertyValue(property.getXSDElement(), property.getXSDType(), reader);
+                            property.setValue(value);
+                            
+                            componentType.getProperties().add(property);
+                            
+                        } else if (Constants.IMPLEMENTATION_QNAME.equals(name)) {
+                            
+                            // Read an <implementation> element
+                            policyProcessor.readPolicies(componentType, reader);
+                            
+                        } else if (Constants.CALLBACK_QNAME.equals(name)) {
+    
+                            // Read a <callback>
+                            callback = assemblyFactory.createCallback();
+                            contract.setCallback(callback);
+                            policyProcessor.readPolicies(callback, reader);
+    
+                        } else if (OPERATION_QNAME.equals(name)) {
+    
+                            // Read an <operation>
+                            Operation operation = new OperationImpl();
+                            operation.setName(getString(reader, NAME));
+                            operation.setUnresolved(true);
+                            if (callback != null) {
+                                policyProcessor.readPolicies(callback, operation, reader);
+                            } else {
+                                policyProcessor.readPolicies(contract, operation, reader);
+                            }
+                        } else {
+    
+                            // Read an extension element
+                            Object extension = extensionProcessor.read(reader);
+                            if (extension != null) {
+                                if (extension instanceof InterfaceContract) {
+    
+                                    // <service><interface> and <reference><interface>
+                                    contract.setInterfaceContract((InterfaceContract)extension);
+    
+                                } else if (extension instanceof Binding) {
+    
+                                    // <service><binding> and <reference><binding>
+                                    if (callback != null) {
+                                        callback.getBindings().add((Binding)extension);
+                                    } else {
+                                        contract.getBindings().add((Binding)extension);
+                                    }
+                                } else {
+                                    
+                                    // Add the extension element to the current element
+                                    if (callback != null) {
+                                        callback.getExtensions().add(extension);
+                                    } else if (contract != null) {
+                                        contract.getExtensions().add(extension);
+                                    } else if (property != null) {
+                                        property.getExtensions().add(extension);
+                                    } else {
+                                        if (componentType instanceof Extensible) {
+                                            ((Extensible)componentType).getExtensions().add(extension);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        break;
+    
+                    case END_ELEMENT:
+                        name = reader.getName();
+    
+                        // Clear current state when reading reaching end element
+                        if (SERVICE_QNAME.equals(name)) {
+                            service = null;
+                            contract = null;
+                        } else if (REFERENCE_QNAME.equals(name)) {
+                            reference = null;
+                            contract = null;
+                        } else if (PROPERTY_QNAME.equals(name)) {
+                            property = null;
+                        } else if (CALLBACK_QNAME.equals(name)) {
+                            callback = null;
+                        }
+                        break;
+                }
+                
+                // Read the next element
+                if (reader.hasNext()) {
+                    reader.next();
+                }
+            }
+        }
+        catch (XMLStreamException e) {
+            ContributionReadException ex = new ContributionReadException(e);
+            error("XMLStreamException", reader, ex);
+        }
+        
+        return componentType;
+    }
+    
+    public void write(ComponentType componentType, XMLStreamWriter writer) throws ContributionWriteException, XMLStreamException {
+        
+        // Write <componentType> element
+        writeStartDocument(writer, COMPONENT_TYPE,
+               writeConstrainingType(componentType));
+
+        // Write <service> elements
+        for (Service service : componentType.getServices()) {
+            writeStart(writer, SERVICE, new XAttr(NAME, service.getName()),
+                       policyProcessor.writePolicies(service));
+
+            if (service.getInterfaceContract() != null) {
+                extensionProcessor.write(service.getInterfaceContract(), writer);
+            }
+            
+            for (Binding binding: service.getBindings()) {
+                extensionProcessor.write(binding, writer);
+            }
+            
+            if (service.getCallback() != null) {
+                Callback callback = service.getCallback();
+                writeStart(writer, CALLBACK, policyProcessor.writePolicies(callback));
+
+                for (Binding binding: callback.getBindings()) {
+                    extensionProcessor.write(binding, writer);
+                }
+                for (Object extension: callback.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+                
+                writeEnd(writer);
+            }
+            
+            for (Object extension: service.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            
+            writeEnd(writer);
+        }
+
+        // Write <reference> elements
+        for (Reference reference : componentType.getReferences()) {
+            
+            writeStart(writer, REFERENCE,
+                  new XAttr(NAME, reference.getName()),
+                  writeMultiplicity(reference),
+                  writeTargets(reference),
+                  policyProcessor.writePolicies(reference));
+
+            extensionProcessor.write(reference.getInterfaceContract(), writer);
+            
+            for (Binding binding: reference.getBindings()) {
+                extensionProcessor.write(binding, writer);
+            }
+            
+            if (reference.getCallback() != null) {
+                Callback callback = reference.getCallback();
+                writeStart(writer, CALLBACK,
+                           policyProcessor.writePolicies(callback));
+
+                for (Binding binding: callback.getBindings()) {
+                    extensionProcessor.write(binding, writer);
+                }
+                for (Object extension: callback.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+                
+                writeEnd(writer);
+            }
+
+            for (Object extension: reference.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            
+            writeEnd(writer);
+        }
+
+        // Write <property> elements
+        for (Property property : componentType.getProperties()) {
+            writeStart(writer,
+                       PROPERTY,
+                       new XAttr(NAME, property.getName()),
+                       new XAttr(MUST_SUPPLY, property.isMustSupply()),
+                       new XAttr(MANY, property.isMany()),
+                       new XAttr(TYPE, property.getXSDType()),
+                       new XAttr(ELEMENT, property.getXSDElement()),
+                       policyProcessor.writePolicies(property));
+
+            // Write property value
+            writePropertyValue(property.getValue(), property.getXSDElement(), property.getXSDType(), writer);
+
+            // Write extensions
+            for (Object extension : property.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+
+            writeEnd(writer);
+        }
+
+        // Write extension elements
+        if (componentType instanceof Extensible) {
+            for (Object extension: ((Extensible)componentType).getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+        }
+        
+        // Write <implementation> elements if the componentType has
+        // any intents or policySets
+        boolean writeImplementation = false;
+        if (componentType instanceof IntentAttachPoint) {
+            if (!((IntentAttachPoint)componentType).getRequiredIntents().isEmpty()) {
+                writeImplementation = true;
+            }
+        }
+        if (componentType instanceof PolicySetAttachPoint) {
+            if (!((PolicySetAttachPoint)componentType).getPolicySets().isEmpty()) {
+                writeImplementation = true;
+            }
+        }
+        if (writeImplementation) {
+            writeStart(writer, IMPLEMENTATION,
+                       policyProcessor.writePolicies(componentType));
+        }
+        
+        writeEndDocument(writer);
+    }
+    
+    public void resolve(ComponentType componentType, ModelResolver resolver) throws ContributionResolveException {
+
+        // Resolve component type services and references
+        resolveContracts(componentType.getServices(), resolver);
+        resolveContracts(componentType.getReferences(), resolver);
+        if ( componentType instanceof PolicySetAttachPoint ) {
+            resolveIntents(((PolicySetAttachPoint)componentType).getRequiredIntents(), resolver);
+            resolvePolicySets(((PolicySetAttachPoint)componentType).getPolicySets(), resolver);
+        }
+    }
+    
+    public QName getArtifactType() {
+        return COMPONENT_TYPE_QNAME;
+    }
+    
+    public Class<ComponentType> getModelType() {
+        return ComponentType.class;
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeDocumentProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeDocumentProcessor.java
new file mode 100644
index 0000000000..6abc28adde
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeDocumentProcessor.java
@@ -0,0 +1,266 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Collection;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+
+import javax.xml.namespace.QName;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.ValidatingXMLInputFactory;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.definitions.SCADefinitions;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.policy.util.PolicyComputationUtils;
+
+/**
+ * A composite processor.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class CompositeDocumentProcessor extends BaseAssemblyProcessor implements URLArtifactProcessor<Composite> {
+    private XMLInputFactory inputFactory;
+    private DocumentBuilderFactory documentBuilderFactory;
+    private List scaDefnSink;
+    private Collection<PolicySet> domainPolicySets = null;
+    private int scaDefnsCount = 0;
+
+    /**
+     * Construct a new composite processor
+     * @param staxProcessor
+     * @param inputFactory
+     * @param scaDefnsSink
+     * @param monitor
+     */
+    @Deprecated
+    public CompositeDocumentProcessor(StAXArtifactProcessor staxProcessor, 
+                                      XMLInputFactory inputFactory,
+                                      List scaDefnsSink, 
+                                      Monitor monitor) {
+        super(null, null, null, staxProcessor, null, monitor);
+        this.inputFactory = inputFactory;
+        this.scaDefnSink = scaDefnsSink;
+    }
+
+
+    /**
+     * Construct a new composite processor
+     * @param staxProcessor
+     * @param inputFactory
+     * @param documentBuilderFactory
+     * @param scaDefnsSink
+     * @param monitor
+     */
+    public CompositeDocumentProcessor(StAXArtifactProcessor staxProcessor, 
+    				      XMLInputFactory inputFactory,
+    				      DocumentBuilderFactory documentBuilderFactory,
+    				      List scaDefnsSink, 
+    				      Monitor monitor) {
+        super(null, null, null, staxProcessor, null, monitor);
+        this.documentBuilderFactory = documentBuilderFactory;
+        this.inputFactory = inputFactory;
+        this.scaDefnSink = scaDefnsSink;
+    }
+
+
+    /**
+     * Construct a new composite processor
+     * @param modelFactories
+     * @param staxProcessor
+     * @param monitor
+     */
+    public CompositeDocumentProcessor(ModelFactoryExtensionPoint modelFactories, 
+    				      StAXArtifactProcessor staxProcessor, 
+    				      Monitor monitor) {
+        super(null, null, null, staxProcessor, null, monitor);
+        this.inputFactory = modelFactories.getFactory(ValidatingXMLInputFactory.class);
+        this.documentBuilderFactory = modelFactories.getFactory(DocumentBuilderFactory.class);
+    }
+    
+    public Composite read(URL contributionURL, URI uri, URL url) throws ContributionReadException {
+        InputStream scdlStream = null;
+        try {
+            URLConnection connection = url.openConnection();
+            connection.setUseCaches(false);
+            try {
+                scdlStream = connection.getInputStream();
+            } catch (IOException e) {
+                if (e.getClass() == IOException.class && connection instanceof HttpURLConnection
+                        && ((HttpURLConnection)connection).getResponseCode() == HttpURLConnection.HTTP_INTERNAL_ERROR) {
+                    error("HttpServerError", url, ((HttpURLConnection)connection).getResponseMessage());
+                }
+                throw e;
+            }
+        } catch (IOException e) {
+            ContributionReadException ce = new ContributionReadException(e);
+            error("ContributionReadException", url, e);
+            throw ce;
+        }
+        return read(uri, scdlStream);
+    }
+
+    public Composite read(URI uri, InputStream scdlStream) throws ContributionReadException {
+        try {
+            if (scaDefnSink != null ) {
+                fillDomainPolicySets(scaDefnSink);
+            }
+            
+            Composite composite = null;
+            
+            byte[] transformedArtifactContent;
+            try {
+                if ( domainPolicySets != null ) {
+                    transformedArtifactContent =
+                        PolicyComputationUtils.addApplicablePolicySets(scdlStream, domainPolicySets, documentBuilderFactory);
+                    scdlStream = new ByteArrayInputStream(transformedArtifactContent);
+                    
+                    // For debugging purposes, write out the XML with applicablePolicySets added
+/*                    
+                    try {
+                        scdlStream.mark(0);
+                        ByteArrayOutputStream tmpOutput = new ByteArrayOutputStream();
+                        while(scdlStream.available()!= 0){
+                            tmpOutput.write(scdlStream.read());
+                        }
+                        System.out.println(tmpOutput);
+                        scdlStream.reset();
+                        
+                    } catch (Exception e){
+                        e.printStackTrace();
+                    }
+*/                    
+                } 
+            } catch ( IOException e ) {
+            	ContributionReadException ce = new ContributionReadException(e);
+            	error("ContributionReadException", scdlStream, e);
+            	throw ce;
+            } catch ( Exception e ) {
+            	ContributionReadException ce = new ContributionReadException(e);
+            	error("ContributionReadException", scdlStream, e);
+                //throw ce;
+            }
+            
+            XMLStreamReader reader = inputFactory.createXMLStreamReader(scdlStream);
+            
+            reader.nextTag();
+            
+            // Read the composite model
+            composite = (Composite)extensionProcessor.read(reader);
+            if (composite != null) {
+                composite.setURI(uri.toString());
+            }
+
+            // For debugging purposes, write it back to XML
+/*
+            if (composite != null) {
+                try {
+                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
+                    XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
+                    outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
+                    extensionProcessor.write(composite, outputFactory.createXMLStreamWriter(bos));
+                    Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(bos.toByteArray()));
+                    OutputFormat format = new OutputFormat();
+                    format.setIndenting(true);
+                    format.setIndent(2);
+                    XMLSerializer serializer = new XMLSerializer(System.out, format);
+                    serializer.serialize(document);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+ */
+            
+            return composite;
+            
+        } catch (XMLStreamException e) {
+        	ContributionReadException ce = new ContributionReadException(e);
+        	error("ContributionReadException", inputFactory, e);
+            throw ce;
+        } finally {
+            try {
+                if (scdlStream != null) {
+                    scdlStream.close();
+                    scdlStream = null;
+                }
+            } catch (IOException ioe) {
+                //ignore
+            }
+        }
+    }
+    
+    public void resolve(Composite composite, ModelResolver resolver) throws ContributionResolveException {
+        if (composite != null)
+    	    extensionProcessor.resolve(composite, resolver);
+    }
+
+    public String getArtifactType() {
+        return ".composite";
+    }
+    
+    public Class<Composite> getModelType() {
+        return Composite.class;
+    }
+    
+    private void fillDomainPolicySets(List scaDefnsSink) {
+        Map<QName, PolicySet> domainPolicySetMap = null;
+        if ( scaDefnsSink.size() > scaDefnsCount ) {
+        //if ( !scaDefnsSink.isEmpty() ) {
+            domainPolicySetMap = new Hashtable<QName, PolicySet>();
+            
+            if ( domainPolicySets != null ) {
+                for ( PolicySet policySet : domainPolicySets ) {
+                    domainPolicySetMap.put(policySet.getName(), policySet);
+                } 
+            }
+            
+            for ( Object object : scaDefnsSink ) {
+                if ( object instanceof SCADefinitions ) {
+                    for ( PolicySet policySet : ((SCADefinitions)object).getPolicySets() ) {
+                        domainPolicySetMap.put( policySet.getName(), policySet);
+                    }
+                }
+            }
+            domainPolicySets =  domainPolicySetMap.values();
+            //scaDefnsSink.clear();
+            scaDefnsCount = scaDefnsSink.size();
+        }
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeModelResolver.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeModelResolver.java
new file mode 100644
index 0000000000..72744259f6
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeModelResolver.java
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.contribution.Contribution;
+import org.apache.tuscany.sca.contribution.Import;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.namespace.NamespaceImport;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+
+/**
+ * A Model Resolver for Composite models.
+ *
+ * @version $Rev$ $Date$
+ */
+public class CompositeModelResolver implements ModelResolver {
+
+    private Contribution contribution;
+    private Map<QName, Composite> map = new HashMap<QName, Composite>();
+    
+    public CompositeModelResolver(Contribution contribution, ModelFactoryExtensionPoint modelFactories) {
+        this.contribution = contribution;
+    }
+
+    public void addModel(Object resolved) {
+        Composite composite = (Composite)resolved;
+        map.put(composite.getName(), composite);
+    }
+    
+    public Object removeModel(Object resolved) {
+        return map.remove(((Composite)resolved).getName());
+    }
+    
+    public <T> T resolveModel(Class<T> modelClass, T unresolved) {
+        
+        // Lookup a definition for the given namespace
+        QName qname = ((Composite)unresolved).getName();
+        Composite resolved = (Composite) map.get(qname);
+        if (resolved != null) {
+            return modelClass.cast(resolved);
+        }
+        
+        // No definition found, delegate the resolution to the imports
+        for (Import import_ : this.contribution.getImports()) {
+            if (import_ instanceof NamespaceImport) {
+                NamespaceImport namespaceImport = (NamespaceImport)import_;
+                if (namespaceImport.getNamespace().equals(qname.getNamespaceURI())) {
+                    
+                    // Delegate the resolution to the import resolver
+                    resolved = namespaceImport.getModelResolver().resolveModel(Composite.class, (Composite)unresolved);
+                    if (!resolved.isUnresolved()) {
+                        return modelClass.cast(resolved);
+                    }
+                }
+            }
+        }
+        return (T)unresolved;
+    }
+    
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeProcessor.java
new file mode 100644
index 0000000000..f34adbc581
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeProcessor.java
@@ -0,0 +1,1243 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
+import static javax.xml.stream.XMLStreamConstants.START_ELEMENT;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.StringTokenizer;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.assembly.Callback;
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.ComponentProperty;
+import org.apache.tuscany.sca.assembly.ComponentReference;
+import org.apache.tuscany.sca.assembly.ComponentService;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.CompositeReference;
+import org.apache.tuscany.sca.assembly.CompositeService;
+import org.apache.tuscany.sca.assembly.ConfiguredOperation;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.assembly.Contract;
+import org.apache.tuscany.sca.assembly.ExtensionFactory;
+import org.apache.tuscany.sca.assembly.Implementation;
+import org.apache.tuscany.sca.assembly.OperationsConfigurator;
+import org.apache.tuscany.sca.assembly.Property;
+import org.apache.tuscany.sca.assembly.Reference;
+import org.apache.tuscany.sca.assembly.Service;
+import org.apache.tuscany.sca.assembly.Wire;
+import org.apache.tuscany.sca.assembly.impl.CompositeImpl;
+import org.apache.tuscany.sca.contribution.Artifact;
+import org.apache.tuscany.sca.contribution.ContributionFactory;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXAttributeProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.resolver.ResolverExtension;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.core.UtilityExtensionPoint;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.monitor.MonitorFactory;
+import org.apache.tuscany.sca.policy.Intent;
+import org.apache.tuscany.sca.policy.IntentAttachPointType;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+import org.apache.tuscany.sca.policy.util.PolicyComputationUtils;
+import org.apache.tuscany.sca.policy.util.PolicyValidationException;
+import org.apache.tuscany.sca.policy.util.PolicyValidationUtils;
+import org.w3c.dom.Document;
+
+/**
+ * A composite processor. 
+ * 
+ * @version $Rev$ $Date$
+ */
+public class CompositeProcessor extends BaseAssemblyProcessor implements StAXArtifactProcessor<Composite> {
+    // FIXME: to be refactored
+    private XPathFactory xPathFactory = XPathFactory.newInstance();
+    
+    /**
+     * Construct a new composite processor
+     * 
+     * @param extensionPoints
+     * @param extensionProcessor
+     */
+    public CompositeProcessor(ExtensionPointRegistry extensionPoints,
+			StAXArtifactProcessor extensionProcessor,
+			StAXAttributeProcessor extensionAttributeProcessor, 
+			Monitor monitor) {
+        
+        this(modelFactories(extensionPoints), 
+             extensionProcessor, 
+             extensionAttributeProcessor, 
+             monitor(extensionPoints));
+        
+    	this.extensionAttributeProcessor = extensionAttributeProcessor;
+    }
+    
+    /**
+     * Constructs a new composite processor
+     * 
+     * @param modelFactories
+     * @param extensionProcessor
+     * @param monitor
+     */
+    private CompositeProcessor(ModelFactoryExtensionPoint modelFactories,
+             StAXArtifactProcessor extensionProcessor,
+             StAXAttributeProcessor extensionAttributeProcessor,
+             Monitor monitor) {
+        
+    	super(modelFactories.getFactory(ContributionFactory.class),
+            modelFactories.getFactory(AssemblyFactory.class),
+            modelFactories.getFactory(ExtensionFactory.class),
+            modelFactories.getFactory(PolicyFactory.class),
+            extensionProcessor, 
+            extensionAttributeProcessor,
+            monitor);
+        
+        this.extensionAttributeProcessor = extensionAttributeProcessor;
+        
+    }
+    
+    /**
+     * Construct a new composite processor
+     * 
+     * @param contributionFactory
+     * @param assemblyFactory
+     * @param policyFactory
+     * @param extensionProcessor
+     */
+    public CompositeProcessor(ContributionFactory contributionFactory,
+            AssemblyFactory assemblyFactory,
+            ExtensionFactory extensionFactory,
+            PolicyFactory policyFactory,
+            StAXArtifactProcessor extensionProcessor,
+            StAXAttributeProcessor extensionAttributeProcessor,
+            Monitor monitor) {
+        super(contributionFactory, assemblyFactory, extensionFactory, policyFactory, extensionProcessor, extensionAttributeProcessor, monitor);
+    }    
+
+    public Composite read(XMLStreamReader reader) throws ContributionReadException {
+        Composite composite = null;
+        Composite include = null;
+        Component component = null;
+        Property property = null;
+        ComponentService componentService = null;
+        ComponentReference componentReference = null;
+        ComponentProperty componentProperty = null;
+        CompositeService compositeService = null;
+        CompositeReference compositeReference = null;
+        Contract contract = null;
+        Wire wire = null;
+        Callback callback = null;
+        QName name = null;
+
+        try {
+            // Read the composite document
+            while (reader.hasNext()) {
+                int event = reader.getEventType();
+                switch (event) {
+                    case START_ELEMENT:
+                        name = reader.getName();
+    
+                        if (COMPOSITE_QNAME.equals(name)) {
+    
+                            // Read a <composite>
+                            composite = assemblyFactory.createComposite();
+                            
+                            composite.setName(new QName(getString(reader, TARGET_NAMESPACE), getString(reader, NAME)));
+    
+                            if(!isSet(reader, TARGET_NAMESPACE)){
+                                // spec says that a composite must have a namespace
+                                warning("NoCompositeNamespace", composite, composite.getName().toString());   
+                            }
+                            
+                            if(isSet(reader, AUTOWIRE)) {
+                                composite.setAutowire(getBoolean(reader, AUTOWIRE));
+                            }
+                            
+                            //handle extension attributes
+                            this.readExtendedAttributes(reader, composite);
+    
+                            composite.setLocal(getBoolean(reader, LOCAL));
+                            composite.setConstrainingType(readConstrainingType(reader));
+                            policyProcessor.readPolicies(composite, reader);
+    
+                        } else if (INCLUDE_QNAME.equals(name)) {
+    
+                            // Read an <include>
+                            include = assemblyFactory.createComposite();
+                            include.setName(getQName(reader, NAME));
+                            include.setURI(getString(reader, URI));
+                            include.setUnresolved(true);
+                            composite.getIncludes().add(include);
+    
+                        } else if (SERVICE_QNAME.equals(name)) {
+                            if (component != null) {
+    
+                                // Read a <component><service>
+                                componentService = assemblyFactory.createComponentService();
+                                contract = componentService;
+                                componentService.setName(getString(reader, NAME));
+                                
+                                //handle extension attributes
+                                this.readExtendedAttributes(reader, componentService);
+    
+                                component.getServices().add(componentService);
+                                policyProcessor.readPolicies(contract, reader);
+                            } else {
+    
+                                // Read a <composite><service>
+                                compositeService = assemblyFactory.createCompositeService();
+                                contract = compositeService;
+                                compositeService.setName(getString(reader, NAME));
+    
+                                String promoted = getString(reader, PROMOTE);
+                                if (promoted != null) {
+                                    String promotedComponentName;
+                                    String promotedServiceName;
+                                    int s = promoted.indexOf('/');
+                                    if (s == -1) {
+                                        promotedComponentName = promoted;
+                                        promotedServiceName = null;
+                                    } else {
+                                        promotedComponentName = promoted.substring(0, s);
+                                        promotedServiceName = promoted.substring(s + 1);
+                                    }
+        
+                                    Component promotedComponent = assemblyFactory.createComponent();
+                                    promotedComponent.setUnresolved(true);
+                                    promotedComponent.setName(promotedComponentName);
+                                    compositeService.setPromotedComponent(promotedComponent);
+        
+                                    ComponentService promotedService = assemblyFactory.createComponentService();
+                                    promotedService.setUnresolved(true);
+                                    promotedService.setName(promotedServiceName);
+                                    compositeService.setPromotedService(promotedService);
+                                }
+    
+                                //handle extension attributes
+                                this.readExtendedAttributes(reader, compositeService);
+    
+                                composite.getServices().add(compositeService);
+                                policyProcessor.readPolicies(contract, reader);
+                            }
+    
+                        } else if (REFERENCE_QNAME.equals(name)) {
+                            if (component != null) {
+                                // Read a <component><reference>
+                                componentReference = assemblyFactory.createComponentReference();
+                                contract = componentReference;
+                                componentReference.setName(getString(reader, NAME));
+                                readMultiplicity(componentReference, reader);
+                                if (isSet(reader, AUTOWIRE)) {
+                                    componentReference.setAutowire(getBoolean(reader, AUTOWIRE));
+                                }
+                                readTargets(componentReference, reader);
+                                componentReference.setWiredByImpl(getBoolean(reader, WIRED_BY_IMPL));
+                                
+                                //handle extension attributes
+                                this.readExtendedAttributes(reader, componentReference);
+    
+                                component.getReferences().add(componentReference);
+                                policyProcessor.readPolicies(contract, reader);
+                            } else {
+                                // Read a <composite><reference>
+                                compositeReference = assemblyFactory.createCompositeReference();
+                                contract = compositeReference;
+                                compositeReference.setName(getString(reader, NAME));
+                                readMultiplicity(compositeReference, reader);
+                                readTargets(compositeReference, reader);
+                                String promote = reader.getAttributeValue(null, Constants.PROMOTE);
+                                if (promote != null) {
+                                    for (StringTokenizer tokens = new StringTokenizer(promote); tokens.hasMoreTokens();) {
+                                        ComponentReference promotedReference =
+                                            assemblyFactory.createComponentReference();
+                                        promotedReference.setUnresolved(true);
+                                        promotedReference.setName(tokens.nextToken());
+                                        compositeReference.getPromotedReferences().add(promotedReference);
+                                    }
+                                }
+                                compositeReference.setWiredByImpl(getBoolean(reader, WIRED_BY_IMPL));
+                                
+                                //handle extension attributes
+                                this.readExtendedAttributes(reader, compositeReference);
+    
+                                composite.getReferences().add(compositeReference);                            
+                                policyProcessor.readPolicies(contract, reader);
+                            }
+    
+                        } else if (PROPERTY_QNAME.equals(name)) {
+                            if (component != null) {
+    
+                                // Read a <component><property>
+                                componentProperty = assemblyFactory.createComponentProperty();
+                                property = componentProperty;
+                                String source = getString(reader, SOURCE);
+                                if(source!=null) {
+                                    source = source.trim();
+                                }
+                                componentProperty.setSource(source);
+                                if (source != null) {
+                                    // $<name>/...
+                                    if (source.charAt(0) == '$') {
+                                        int index = source.indexOf('/');
+                                        if (index == -1) {
+                                            // Tolerating $prop
+                                            source = source + "/";
+                                            index = source.length() - 1;
+                                        }
+                                        source = source.substring(index + 1);
+                                        if ("".equals(source)) {
+                                            source = ".";
+                                        }
+                                    }
+                                    XPath xpath = xPathFactory.newXPath();
+                                    xpath.setNamespaceContext(reader.getNamespaceContext());
+                                    try {
+                                        componentProperty.setSourceXPathExpression(xpath.compile(source));
+                                    } catch (XPathExpressionException e) {
+                                    	ContributionReadException ce = new ContributionReadException(e);
+                                    	error("ContributionReadException", xpath, ce);
+                                        //throw ce;
+                                    }
+                                }
+                                componentProperty.setFile(getString(reader, FILE));
+                                
+                                //handle extension attributes
+                                this.readExtendedAttributes(reader, componentProperty);
+    
+                                policyProcessor.readPolicies(property, reader);
+                                readAbstractProperty(componentProperty, reader);
+                                
+                                // Read the property value
+                                Document value = readPropertyValue(property.getXSDElement(), property.getXSDType(), reader);
+                                property.setValue(value);
+                                
+                                component.getProperties().add(componentProperty);
+                            } else {
+    
+                                // Read a <composite><property>
+                                property = assemblyFactory.createProperty();
+                                policyProcessor.readPolicies(property, reader);
+                                readAbstractProperty(property, reader);
+                                
+                                // Read the property value
+                                Document value = readPropertyValue(property.getXSDElement(), property.getXSDType(), reader);
+                                property.setValue(value);
+                                
+                                composite.getProperties().add(property);
+                            }
+                            
+                            // TUSCANY-1949
+                            // If the property doesn't have a value, the END_ELEMENT event is read by the readPropertyValue
+                            if (reader.getEventType() == END_ELEMENT && PROPERTY_QNAME.equals(reader.getName())) {
+                                property = null;
+                                componentProperty = null;
+                            }
+    
+                        } else if (COMPONENT_QNAME.equals(name)) {
+    
+                            // Read a <component>
+                            component = assemblyFactory.createComponent();
+                            component.setName(getString(reader, NAME));
+                            if (isSet(reader, AUTOWIRE)) {
+                                component.setAutowire(getBoolean(reader, AUTOWIRE));
+                            }
+                            if (isSet(reader, URI)) {
+                                component.setURI(getString(reader, URI));
+                            }
+                            
+                            //handle extension attributes
+                           this.readExtendedAttributes(reader, component);
+                            
+                            component.setConstrainingType(readConstrainingType(reader));
+                            composite.getComponents().add(component);
+                            policyProcessor.readPolicies(component, reader);
+    
+                        } else if (WIRE_QNAME.equals(name)) {
+    
+                            // Read a <wire>
+                            wire = assemblyFactory.createWire();
+                            ComponentReference source = assemblyFactory.createComponentReference();
+                            source.setUnresolved(true);
+                            source.setName(getString(reader, SOURCE));
+                            wire.setSource(source);
+    
+                            ComponentService target = assemblyFactory.createComponentService();
+                            target.setUnresolved(true);
+                            target.setName(getString(reader, TARGET));
+                            wire.setTarget(target);
+    
+                            //handle extension attributes
+                            this.readExtendedAttributes(reader, wire);
+    
+                            composite.getWires().add(wire);
+                            policyProcessor.readPolicies(wire, reader);
+    
+                        } else if (CALLBACK_QNAME.equals(name)) {
+    
+                            // Read a <callback>
+                            callback = assemblyFactory.createCallback();
+                            contract.setCallback(callback);
+                            
+                            //handle extension attributes
+                            this.readExtendedAttributes(reader, callback);
+                            
+                            policyProcessor.readPolicies(callback, reader);
+    
+                        } else if (OPERATION_QNAME.equals(name)) {
+    
+                            // Read an <operation>
+                            ConfiguredOperation operation = assemblyFactory.createConfiguredOperation();
+                            operation.setName(getString(reader, NAME));
+                            operation.setUnresolved(true);
+                            if (callback != null) {
+                                policyProcessor.readPolicies(operation, reader);
+                            } else {
+                                policyProcessor.readPolicies(operation, reader);
+                            }
+                            
+                            OperationsConfigurator opConfigurator = null;
+                            if ( compositeService != null ) {
+                                opConfigurator = compositeService;
+                            } else if ( componentService != null ) {
+                                opConfigurator = componentService;
+                            } else if ( compositeReference != null ) {
+                                opConfigurator = compositeReference;
+                            } else if ( componentReference != null ) {
+                                opConfigurator = componentReference;
+                            }
+                            
+                            opConfigurator.getConfiguredOperations().add(operation);
+                        } else if (IMPLEMENTATION_COMPOSITE_QNAME.equals(name)) {
+    
+                            // Read an implementation.composite
+                            Composite implementation = assemblyFactory.createComposite();
+                            implementation.setName(getQName(reader, NAME));
+                            implementation.setUnresolved(true);
+                            
+                            //handle extension attributes
+                            this.readExtendedAttributes(reader, implementation);
+    
+                            component.setImplementation(implementation);
+                            policyProcessor.readPolicies(implementation, reader);
+                        } else {
+    
+                            // Read an extension element
+                            Object extension = extensionProcessor.read(reader);
+                            if (extension != null) {
+                                if (extension instanceof InterfaceContract) {
+    
+                                    // <service><interface> and
+                                    // <reference><interface>
+                                    if (contract != null) {
+                                        contract.setInterfaceContract((InterfaceContract)extension);
+                                    } else {
+                                        if (name.getNamespaceURI().equals(SCA10_NS)) {
+                                        	error("UnexpectedInterfaceElement", extension);
+                                            //throw new ContributionReadException("Unexpected <interface> element found. It should appear inside a <service> or <reference> element");
+                                        } else {
+                                            composite.getExtensions().add(extension);
+                                        }
+                                    }
+                                } else if (extension instanceof Binding) {
+                                    if ( extension instanceof PolicySetAttachPoint ) {
+                                        IntentAttachPointType bindingType = intentAttachPointTypeFactory.createBindingType();
+                                        bindingType.setName(name);
+                                        bindingType.setUnresolved(true);
+                                        ((PolicySetAttachPoint)extension).setType(bindingType);
+                                    }
+                                    // <service><binding> and
+                                    // <reference><binding>
+                                    if (callback != null) {
+                                        callback.getBindings().add((Binding)extension);
+                                    } else {
+                                        if (contract != null) {
+                                            contract.getBindings().add((Binding)extension);
+                                        } else {
+                                            if (name.getNamespaceURI().equals(SCA10_NS)) {
+                                            	error("UnexpectedBindingElement", extension);
+                                                //throw new ContributionReadException("Unexpected <binding> element found. It should appear inside a <service> or <reference> element");
+                                            } else {
+                                                composite.getExtensions().add(extension);
+                                            }
+                                        }
+                                    }
+    
+                                } else if (extension instanceof Implementation) {
+                                    if ( extension instanceof PolicySetAttachPoint ) {
+                                        IntentAttachPointType implType = intentAttachPointTypeFactory.createImplementationType();
+                                        implType.setName(name);
+                                        implType.setUnresolved(true);
+                                        ((PolicySetAttachPoint)extension).setType(implType);
+                                    }
+                                    // <component><implementation>
+                                    if (component != null) {
+                                        component.setImplementation((Implementation)extension);
+                                    } else {
+                                        if (name.getNamespaceURI().equals(SCA10_NS)) {
+                                        	error("UnexpectedImplementationElement", extension);
+                                            //throw new ContributionReadException("Unexpected <implementation> element found. It should appear inside a <component> element");
+                                        } else {
+                                            composite.getExtensions().add(extension);
+                                        }
+                                    }
+                                } else {
+    
+                                    // Add the extension element to the current
+                                    // element
+                                    if (callback != null) {
+                                        callback.getExtensions().add(extension);
+                                    } else if (contract != null) {
+                                        contract.getExtensions().add(extension);
+                                    } else if (property != null) {
+                                        property.getExtensions().add(extension);
+                                    } else if (component != null) {
+                                        component.getExtensions().add(extension);
+                                    } else {
+                                        composite.getExtensions().add(extension);
+                                    }
+                                }
+                            }
+                        }
+                        break;
+    
+                    case XMLStreamConstants.CHARACTERS:
+                        break;
+    
+                    case END_ELEMENT:
+                        name = reader.getName();
+    
+                        // Clear current state when reading reaching end element
+                        if (SERVICE_QNAME.equals(name)) {
+                            componentService = null;
+                            compositeService = null;
+                            contract = null;
+                        } else if (INCLUDE_QNAME.equals(name)) {
+                            include = null;
+                        } else if (REFERENCE_QNAME.equals(name)) {
+                            componentReference = null;
+                            compositeReference = null;
+                            contract = null;
+                        } else if (PROPERTY_QNAME.equals(name)) {
+                            componentProperty = null;
+                            property = null;
+                        } else if (COMPONENT_QNAME.equals(name)) {
+                            component = null;
+                        } else if (WIRE_QNAME.equals(name)) {
+                            wire = null;
+                        } else if (CALLBACK_QNAME.equals(name)) {
+                            callback = null;
+                        }
+                        break;
+                }
+    
+                // Read the next element
+                if (reader.hasNext()) {
+                    reader.next();
+                }
+            }
+        }
+        catch (XMLStreamException e) {
+            ContributionReadException ex = new ContributionReadException(e);
+            error("ContributionReadException", reader, ex);
+        }
+        
+        return composite;
+    }
+
+    public void write(Composite composite, XMLStreamWriter writer) throws ContributionWriteException, XMLStreamException {
+
+        // Write <composite> element
+        writeStartDocument(writer,
+                           COMPOSITE,
+                           writeConstrainingType(composite),
+                           new XAttr(TARGET_NAMESPACE, composite.getName().getNamespaceURI()),
+                           new XAttr(NAME, composite.getName().getLocalPart()),
+                           new XAttr(LOCAL, composite.isLocal() ? Boolean.TRUE : null),
+                           new XAttr(AUTOWIRE, composite.getAutowire()),
+                           policyProcessor.writePolicies(composite));
+        
+        //write extended attributes
+        this.writeExtendedAttributes(writer, composite, extensionAttributeProcessor);
+
+        // Write <include> elements
+        for (Composite include : composite.getIncludes()) {
+            String uri = include.isUnresolved()? include.getURI() : null;
+            writeStart(writer,
+                       INCLUDE,
+                       new XAttr(NAME, include.getName()),
+                       new XAttr(URI, uri));
+
+            //write extended attributes
+            this.writeExtendedAttributes(writer, include, extensionAttributeProcessor);
+            
+            writeEnd(writer);
+        }
+
+        // Write <service> elements
+        for (Service service : composite.getServices()) {
+            CompositeService compositeService = (CompositeService)service;
+            Component promotedComponent = compositeService.getPromotedComponent();
+            ComponentService promotedService = compositeService.getPromotedService();
+            String promote;
+            if (promotedService != null) {
+                if (promotedService.getName() != null) {
+                    promote = promotedComponent.getName() + '/' + promotedService.getName();
+                } else {
+                    promote = promotedComponent.getName();
+                }
+            } else {
+                promote = null;
+            }
+            writeStart(writer, SERVICE, new XAttr(NAME, service.getName()), new XAttr(PROMOTE, promote),
+                       policyProcessor.writePolicies(service));
+            
+            //write extended attributes
+            this.writeExtendedAttributes(writer, service, extensionAttributeProcessor);
+
+            
+            // Write service interface
+            extensionProcessor.write(service.getInterfaceContract(), writer);
+
+            // Write bindings
+            for (Binding binding : service.getBindings()) {
+                extensionProcessor.write(binding, writer);
+            }
+
+            // Write <callback> element
+            if (service.getCallback() != null) {
+                Callback callback = service.getCallback();
+                writeStart(writer, CALLBACK,
+                           policyProcessor.writePolicies(callback));
+            
+                //write extended attributes
+                this.writeExtendedAttributes(writer, callback, extensionAttributeProcessor);
+
+                // Write callback bindings
+                for (Binding binding : callback.getBindings()) {
+                    extensionProcessor.write(binding, writer);
+                }
+                
+                // Write extensions 
+                for (Object extension : callback.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+            
+                writeEnd(writer);
+            }
+
+            // Write extensions
+            for (Object extension : service.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            
+            writeEnd(writer);
+        }
+
+        // Write <component> elements
+        for (Component component : composite.getComponents()) {
+            writeStart(writer, COMPONENT, new XAttr(NAME, component.getName()),
+                       new XAttr(URI, component.getURI()),
+                       new XAttr(AUTOWIRE, component.getAutowire()),
+                       policyProcessor.writePolicies(component));
+            
+            //write extended attributes
+            this.writeExtendedAttributes(writer, component, extensionAttributeProcessor);
+            
+            // Write the component implementation
+            Implementation implementation = component.getImplementation();
+            // check that we really have CompositeImpl and treat this specially. Some
+            // extension extend CompositeImpl and we want these to be treated by the extension 
+            // processor.
+            if ((implementation != null ) && (implementation.getClass().equals(CompositeImpl.class))) {
+                writeStart(writer, IMPLEMENTATION_COMPOSITE, new XAttr(NAME, ((Composite)implementation).getName()));
+                
+                //write extended attributes
+                this.writeExtendedAttributes(writer, (Composite)implementation, extensionAttributeProcessor);
+
+                writeEnd(writer);
+            } else {
+                extensionProcessor.write(component.getImplementation(), writer);
+            }
+            
+            for (Object extension : component.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }            
+            
+            // Write <service> elements
+            for (ComponentService service : component.getServices()) {
+            	if (service.isCallback() == false){
+	                writeStart(writer, SERVICE, new XAttr(NAME, service.getName()),
+	                           policyProcessor.writePolicies(service));
+	
+	                //write extended attributes
+	                this.writeExtendedAttributes(writer, service, extensionAttributeProcessor);
+	
+	                // Write service interface
+	                extensionProcessor.write(service.getInterfaceContract(), writer);
+	                
+	                // Write bindings
+	                for (Binding binding : service.getBindings()) {
+	                    extensionProcessor.write(binding, writer);
+	                }
+	                
+	                // Write <callback> element
+	                if (service.getCallback() != null) {
+	                    Callback callback = service.getCallback();
+	                    writeStart(writer, CALLBACK, policyProcessor.writePolicies(callback));
+	
+	                    //write extended attributes
+	                    this.writeExtendedAttributes(writer, callback, extensionAttributeProcessor);
+	
+	                    // Write bindings
+	                    for (Binding binding : callback.getBindings()) {
+	                        extensionProcessor.write(binding, writer);
+	                    }
+	                    
+	                    // Write extensions 
+	                    for (Object extension : callback.getExtensions()) {
+	                        extensionProcessor.write(extension, writer);
+	                    }
+	                
+	                    writeEnd(writer);
+	                }
+	                
+	                // Write extensions
+	                for (Object extension : service.getExtensions()) {
+	                    extensionProcessor.write(extension, writer);
+	                }
+	                
+	                writeEnd(writer);
+            	}
+            }
+            
+            // Write <reference> elements
+            for (ComponentReference reference : component.getReferences()) {
+            	if (reference.isCallback() == false){
+	                writeStart(writer, REFERENCE, new XAttr(NAME, reference.getName()),
+	                           new XAttr(AUTOWIRE, reference.getAutowire()),
+	                           writeMultiplicity(reference),
+	                           writeTargets(reference),
+	                           policyProcessor.writePolicies(reference));
+	
+	                //write extended attributes
+	                this.writeExtendedAttributes(writer, reference, extensionAttributeProcessor);
+	
+	                // Write reference interface
+	                extensionProcessor.write(reference.getInterfaceContract(), writer);
+	
+	                // Write bindings
+	                for (Binding binding : reference.getBindings()) {
+	                    extensionProcessor.write(binding, writer);
+	                }
+	                
+	                // Write callback
+	                if (reference.getCallback() != null) {
+	                    Callback callback = reference.getCallback();
+	                    writeStart(writer, CALLBACK, policyProcessor.writePolicies(callback));
+	                
+	                    //write extended attributes
+	                    this.writeExtendedAttributes(writer, callback, extensionAttributeProcessor);
+	
+	                    // Write callback bindings
+	                    for (Binding binding : callback.getBindings()) {
+	                        extensionProcessor.write(binding, writer);
+	                    }
+	                    
+	                    // Write extensions
+	                    for (Object extensions : callback.getExtensions()) {
+	                        extensionProcessor.write(extensions, writer);
+	                    }
+	                
+	                    writeEnd(writer);
+	                }
+	                
+	                // Write extensions
+	                for (Object extensions : reference.getExtensions()) {
+	                    extensionProcessor.write(extensions, writer);
+	                }
+	                
+	                writeEnd(writer);
+            	}
+            }
+            
+            // Write <property> elements
+            for (ComponentProperty property : component.getProperties()) {
+                writeStart(writer,
+                           PROPERTY,
+                           new XAttr(NAME, property.getName()),
+                           new XAttr(MUST_SUPPLY, property.isMustSupply()),
+                           new XAttr(MANY, property.isMany()),
+                           new XAttr(TYPE, property.getXSDType()),
+                           new XAttr(ELEMENT, property.getXSDElement()),
+                           new XAttr(SOURCE, property.getSource()),
+                           new XAttr(FILE, property.getFile()),
+                           policyProcessor.writePolicies(property));
+
+                //write extended attributes
+                this.writeExtendedAttributes(writer, property, extensionAttributeProcessor);
+
+                // Write property value
+                writePropertyValue(property.getValue(), property.getXSDElement(), property.getXSDType(), writer);
+
+                // Write extensions
+                for (Object extension : property.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+
+                writeEnd(writer);
+            }
+ 
+            writeEnd(writer);
+        }
+
+        // Write <reference> elements
+        for (Reference reference : composite.getReferences()) {
+            CompositeReference compositeReference = (CompositeReference)reference;
+
+            // Write list of promoted references
+            List<String> promote = new ArrayList<String>();
+            for (ComponentReference promoted: compositeReference.getPromotedReferences()) {
+                promote.add(promoted.getName());
+            }
+            
+            // Write <reference> element
+            writeStart(writer, REFERENCE, new XAttr(NAME, reference.getName()),
+                       new XAttr(PROMOTE, promote),
+                       writeMultiplicity(reference),
+                       policyProcessor.writePolicies(reference));
+
+            //write extended attributes
+            this.writeExtendedAttributes(writer, reference, extensionAttributeProcessor);
+
+            // Write reference interface
+            extensionProcessor.write(reference.getInterfaceContract(), writer);
+            
+            // Write bindings
+            for (Binding binding : reference.getBindings()) {
+                extensionProcessor.write(binding, writer);
+            }
+            
+            // Write <callback> element
+            if (reference.getCallback() != null) {
+                Callback callback = reference.getCallback();
+                writeStart(writer, CALLBACK);
+            
+                //write extended attributes
+                this.writeExtendedAttributes(writer, callback, extensionAttributeProcessor);
+
+                // Write callback bindings
+                for (Binding binding : callback.getBindings()) {
+                    extensionProcessor.write(binding, writer);
+                }
+                
+                // Write extensions
+                for (Object extension : callback.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+            
+                writeEnd(writer);
+            }
+            
+            // Write extensions
+            for (Object extension : reference.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            
+            writeEnd(writer);
+        }
+
+        // Write <property> elements
+        for (Property property : composite.getProperties()) {
+            writeStart(writer,
+                       PROPERTY,
+                       new XAttr(NAME, property.getName()),
+                       new XAttr(MUST_SUPPLY, property.isMustSupply()),
+                       new XAttr(MANY, property.isMany()),
+                       new XAttr(TYPE, property.getXSDType()),
+                       new XAttr(ELEMENT, property.getXSDElement()),
+                       policyProcessor.writePolicies(property));
+
+            //write extended attributes
+            this.writeExtendedAttributes(writer, property, extensionAttributeProcessor);
+
+            // Write property value
+            writePropertyValue(property.getValue(), property.getXSDElement(), property.getXSDType(), writer);
+
+            // Write extensions
+            for (Object extension : property.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+
+            writeEnd(writer);
+        }
+
+        // Write <wire> elements
+        for (Wire wire : composite.getWires()) {
+            writeStart(writer, WIRE, new XAttr(SOURCE, wire.getSource().getName()), new XAttr(TARGET, wire
+                .getTarget().getName()));
+            
+            //write extended attributes
+            this.writeExtendedAttributes(writer, wire, extensionAttributeProcessor);
+
+            // Write extensions
+            for (Object extension : wire.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            writeEnd(writer);
+        }
+
+        for (Object extension : composite.getExtensions()) {
+        		extensionProcessor.write(extension, writer);
+        }
+        
+        writeEndDocument(writer);
+    }
+
+    public void resolve(Composite composite, ModelResolver resolver) throws ContributionResolveException {
+
+        // Resolve constraining type
+        ConstrainingType constrainingType = composite.getConstrainingType();
+        if (constrainingType != null) {
+            constrainingType = resolver.resolveModel(ConstrainingType.class, constrainingType);
+            composite.setConstrainingType(constrainingType);
+        }
+
+        // Resolve includes in the composite
+        for (int i = 0, n = composite.getIncludes().size(); i < n; i++) {
+            Composite include = composite.getIncludes().get(i);
+            if (include != null) {
+                include = resolver.resolveModel(Composite.class, include);
+                composite.getIncludes().set(i, include);
+            }
+        }
+
+        // Resolve extensions
+        for (Object extension : composite.getExtensions()) {
+            if (extension != null) {
+                extensionProcessor.resolve(extension, resolver);
+            }
+        }
+        
+        //resolve intents and policy sets
+        List<Intent> compositeIntents = null;
+        List<PolicySet> compositePolicySets = null;
+        List<PolicySet> compositeApplicablePolicySets = null;
+        resolveIntents(composite.getRequiredIntents(), resolver);
+        resolvePolicySets(composite.getPolicySets(), resolver);
+        resolvePolicySets(composite.getApplicablePolicySets(), resolver);
+        compositeIntents = composite.getRequiredIntents();
+        compositePolicySets = composite.getPolicySets();
+        compositeApplicablePolicySets = composite.getApplicablePolicySets();
+
+        //Resolve composite services and references
+        resolveContracts(composite, composite.getServices(), resolver);
+        resolveContracts(composite, composite.getReferences(), resolver);
+
+        // Resolve component implementations, services and references
+        for (Component component : composite.getComponents()) {
+            constrainingType = component.getConstrainingType();
+            if (constrainingType != null) {
+                constrainingType = resolver.resolveModel(ConstrainingType.class, constrainingType);
+                component.setConstrainingType(constrainingType);
+            }
+            
+            //resolve intents and policy sets
+            resolveIntents(component.getRequiredIntents(), resolver);
+            resolvePolicySets(component.getPolicySets(), resolver);
+            resolvePolicySets(component.getApplicablePolicySets(), resolver);
+            
+            //inherit composite intents and policysets
+            PolicyComputationUtils.addDefaultPolicies(compositeIntents,
+                                                      compositePolicySets,
+                                                      component.getRequiredIntents(),
+                                                      component.getPolicySets());
+
+            addInheritedPolicySets(compositeApplicablePolicySets, component.getApplicablePolicySets());
+
+            //resolve component services and references 
+            resolveContracts(component, component.getServices(), resolver);
+            resolveContracts(component, component.getReferences(), resolver);
+            
+            for (ComponentProperty componentProperty : component.getProperties()) {
+                if (componentProperty.getFile() != null) {
+                    Artifact artifact = contributionFactory.createArtifact();
+                    artifact.setURI(componentProperty.getFile());
+                    artifact = resolver.resolveModel(Artifact.class, artifact);
+                    if (artifact.getLocation() != null) {
+                        componentProperty.setFile(artifact.getLocation());
+                    }
+                }
+            }
+            
+            //resolve component implementation
+            Implementation implementation = component.getImplementation();
+            if (implementation != null) {
+                try {
+                    //resolve intents and policysets specified on this implementation
+                    //before copying them over to the component.  Before that, from the component
+                    //copy over the applicablePolicySets alone as it might have to be
+                    //used to validate the policysets specified on the implementation
+                    
+                    resolveImplIntentsAndPolicySets(implementation, 
+                                                    component.getApplicablePolicySets(), 
+                                                    resolver);
+
+                    copyPoliciesToComponent(component, implementation, resolver, true);
+                    
+                    //now resolve the implementation so that even if there is a shared instance
+                    //for this that is resolved, the specified intents and policysets are safe in the
+                    //component and not lost
+                    implementation = resolveImplementation(implementation, resolver);
+                    
+                    //resolved implementation may contain intents and policysets specified at 
+                    //componentType (either in the componentType side file or in annotations if its a 
+                    //java implementation).  This has to be consolidated in to the component.
+                    copyPoliciesToComponent(component, implementation, resolver, false);
+                    
+                    component.setImplementation(implementation);
+                } catch ( PolicyValidationException e ) {
+                	error("PolicyImplValidationException", resolver, component.getName(), e.getMessage());
+                    //throw new ContributionResolveException("PolicyValidation exception when processing implementation of component '" 
+                                                           //+ component.getName() + "' due to " + e.getMessage(), e);
+                }
+            
+            }
+
+            //add model resolver to component
+            if (component instanceof ResolverExtension) {
+                ((ResolverExtension)component).setModelResolver(resolver);
+            }
+        }
+
+        // Add model resolver to promoted components
+        for (Service service : composite.getServices()) {
+            CompositeService compositeService = (CompositeService)service;
+            Component promotedComponent = compositeService.getPromotedComponent();
+            if (promotedComponent instanceof ResolverExtension) {
+                ((ResolverExtension)promotedComponent).setModelResolver(resolver);
+            }
+        }
+    }
+    
+    private void resolveImplIntentsAndPolicySets(Implementation implementation,
+                                                 List<PolicySet> inheritedApplicablePolicySets,
+                                                 ModelResolver resolver) throws ContributionResolveException,
+                                                                                 PolicyValidationException
+                                                        {
+        if ( implementation instanceof PolicySetAttachPoint ) {
+            PolicySetAttachPoint policiedImpl = (PolicySetAttachPoint)implementation;
+            
+            policiedImpl.getApplicablePolicySets().addAll(inheritedApplicablePolicySets);
+            
+            resolveIntents(policiedImpl.getRequiredIntents(), resolver);
+            PolicyValidationUtils.validateIntents(policiedImpl, policiedImpl.getType());
+            
+            resolvePolicySets(policiedImpl.getPolicySets(), resolver);
+            resolvePolicySets(policiedImpl.getApplicablePolicySets(), resolver);
+            
+            PolicyValidationUtils.validatePolicySets(policiedImpl);
+            
+            if ( implementation instanceof OperationsConfigurator ) {
+                for ( ConfiguredOperation implConfOp : ((OperationsConfigurator)implementation).getConfiguredOperations() ) {
+                    resolveIntents(implConfOp.getRequiredIntents(), resolver);
+                    PolicyValidationUtils.validateIntents(implConfOp, policiedImpl.getType());
+                    
+                    resolvePolicySets(implConfOp.getPolicySets(), resolver);
+                    resolvePolicySets(implConfOp.getApplicablePolicySets(), resolver);
+                    //add the inherited applicablePolicysets
+                    addInheritedPolicySets(policiedImpl.getApplicablePolicySets(), implConfOp.getApplicablePolicySets());
+                    
+                    PolicyValidationUtils.validatePolicySets(implConfOp, policiedImpl.getType());
+                    
+                    PolicyComputationUtils.addDefaultPolicies(
+                                            ((PolicySetAttachPoint)implementation).getRequiredIntents(),
+                                            ((PolicySetAttachPoint)implementation).getPolicySets(),
+                                            implConfOp.getRequiredIntents(),
+                                            implConfOp.getPolicySets());
+                }
+            }
+        }
+    }
+    
+    private void copyPoliciesToComponent(Component component, 
+                                         Implementation implementation, 
+                                         ModelResolver resolver,
+                                         boolean clearImplSettings) throws ContributionResolveException {
+        if (implementation instanceof PolicySetAttachPoint) {
+            // Add implementation policies into component, since implementation instances are 
+            // reused and it's likely that this implementation instance will not hold after its resolution.
+            // On the first call to this method (clearImplSettings=true), we are moving policies from the
+            // implementation XML element up to the component.  In this case if there are mutually exclusive
+            // policies we must clear the component policy so that the implementation policy "wins".
+            // On the second call to this method (clearImplSettings=false), we are moving policies from the
+            // componentType implementation up to the component.  In this case if there are mutually
+            // exclusive policies it is an error.  This error will be detected later in the PolicyComputer.
+            if (clearImplSettings) {
+                for (Intent intent : ((PolicySetAttachPoint)implementation).getRequiredIntents()) {
+                    for (Intent excluded : intent.getExcludedIntents()) {
+                        if (component.getRequiredIntents().contains(excluded)) {
+                            component.getRequiredIntents().remove(excluded);
+                        }
+                        for (Iterator i = component.getPolicySets().iterator(); i.hasNext(); ) {
+                            PolicySet cmpPolicySet = (PolicySet) i.next();
+                            if (cmpPolicySet.getProvidedIntents().contains(excluded)) {
+                                i.remove();
+                            }
+                        }
+                    }
+                }
+                for (PolicySet policySet : ((PolicySetAttachPoint)implementation).getPolicySets()) {
+                    for (Intent intent : policySet.getProvidedIntents()) {
+                        for (Intent excluded : intent.getExcludedIntents()) {
+                            if (component.getRequiredIntents().contains(excluded)) {
+                                component.getRequiredIntents().remove(excluded);
+                            }
+                            for (Iterator i = component.getPolicySets().iterator(); i.hasNext(); ) {
+                                PolicySet cmpPolicySet = (PolicySet) i.next();
+                                if (cmpPolicySet.getProvidedIntents().contains(excluded)) {
+                                    i.remove();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            component.getRequiredIntents().addAll(((PolicySetAttachPoint)implementation).getRequiredIntents());
+            component.getPolicySets().addAll(((PolicySetAttachPoint)implementation).getPolicySets());
+            component.getApplicablePolicySets().addAll(((PolicySetAttachPoint)implementation).getApplicablePolicySets());
+            
+            if ( implementation instanceof OperationsConfigurator ) {
+                boolean notFound;
+                List<ConfiguredOperation> opsFromImplementation = new ArrayList<ConfiguredOperation>();
+                List<ConfiguredOperation> implConfOperations = 
+                    new ArrayList<ConfiguredOperation>(((OperationsConfigurator)implementation).getConfiguredOperations());
+                for ( ConfiguredOperation implConfOp : implConfOperations ) {
+                    notFound = true;
+                    for ( ConfiguredOperation compConfOp : ((OperationsConfigurator)component).getConfiguredOperations() ) {
+                        if ( implConfOp.getName().equals(compConfOp.getName()) ) {
+                            notFound = false;
+
+                            if (clearImplSettings) {
+                                for (Intent intent : implConfOp.getRequiredIntents()) {
+                                    for (Intent excluded : intent.getExcludedIntents()) {
+                                        if (compConfOp.getRequiredIntents().contains(excluded)) {
+                                            compConfOp.getRequiredIntents().remove(excluded);
+                                        }
+                                    }
+                                }
+                                for (PolicySet policySet : implConfOp.getPolicySets()) {
+                                    for (Intent intent : policySet.getProvidedIntents()) {
+                                        for (Intent excluded : intent.getExcludedIntents()) {
+                                            if (compConfOp.getRequiredIntents().contains(excluded)) {
+                                                compConfOp.getRequiredIntents().remove(excluded);
+                                            }
+                                            for (Iterator i = compConfOp.getPolicySets().iterator(); i.hasNext(); ) {
+                                                PolicySet cmpPolicySet = (PolicySet) i.next();
+                                                if (cmpPolicySet.getProvidedIntents().contains(excluded)) {
+                                                    i.remove();
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            addInheritedIntents(implConfOp.getRequiredIntents(), compConfOp.getRequiredIntents());
+                            addInheritedPolicySets(implConfOp.getPolicySets(), compConfOp.getPolicySets());
+                            addInheritedPolicySets(implConfOp.getApplicablePolicySets(), compConfOp.getApplicablePolicySets());
+                        }
+                    }
+                    
+                    if ( notFound ) {
+                        opsFromImplementation.add(implConfOp);
+                    }
+                    
+                    if ( clearImplSettings ) {
+                        ((OperationsConfigurator)implementation).getConfiguredOperations().remove(implConfOp);
+                    }
+                }
+                ((OperationsConfigurator)component).getConfiguredOperations().addAll(opsFromImplementation);
+            }
+            
+            if ( clearImplSettings ) {
+                ((PolicySetAttachPoint)implementation).getRequiredIntents().clear();
+                ((PolicySetAttachPoint)implementation).getPolicySets().clear();
+            }
+        }
+    }
+    
+    
+    public QName getArtifactType() {
+        return COMPOSITE_QNAME;
+    }
+
+    public Class<Composite> getModelType() {
+        return Composite.class;
+    }
+
+    /**
+     * Returns the model factory extension point to use.
+     * 
+     * @param extensionPoints
+     * @return
+     */
+    private static ModelFactoryExtensionPoint modelFactories(ExtensionPointRegistry extensionPoints) {
+        return extensionPoints.getExtensionPoint(ModelFactoryExtensionPoint.class);
+    }
+    
+    /**
+     * Returns the monitor to use.
+     * 
+     * @param extensionPoints
+     * @return
+     */
+    private static Monitor monitor(ExtensionPointRegistry extensionPoints) {
+        UtilityExtensionPoint utilities = extensionPoints.getExtensionPoint(UtilityExtensionPoint.class);
+        if (utilities != null) {
+            MonitorFactory monitorFactory = utilities.getUtility(MonitorFactory.class);
+            if (monitorFactory != null) {
+                return monitorFactory.createMonitor();
+            }
+        }
+        return null;
+    }
+    
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConfiguredOperationProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConfiguredOperationProcessor.java
new file mode 100644
index 0000000000..0f062dbda5
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConfiguredOperationProcessor.java
@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.ConfiguredOperation;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+
+/**
+ * Processor for dealing with  'operation' elements from composite definitions
+ *
+ * @version $Rev$ $Date$
+ */
+public class ConfiguredOperationProcessor implements StAXArtifactProcessor<ConfiguredOperation>, Constants{
+
+    private AssemblyFactory assemblyFactory;
+    private PolicyAttachPointProcessor policyProcessor;
+    private PolicyFactory policyFactory;
+    private Monitor monitor;
+
+    public ConfiguredOperationProcessor(ModelFactoryExtensionPoint modelFactories, Monitor monitor) {
+        this.assemblyFactory = modelFactories.getFactory(AssemblyFactory.class);
+        this.policyFactory = modelFactories.getFactory(PolicyFactory.class);
+        this.policyProcessor = new PolicyAttachPointProcessor(policyFactory);
+        this.monitor = monitor;
+    }
+
+    public ConfiguredOperation read(XMLStreamReader reader) throws ContributionReadException, XMLStreamException {
+        ConfiguredOperation  configuredOp = assemblyFactory.createConfiguredOperation();
+
+        //Read an <operation>
+        configuredOp.setName(reader.getAttributeValue(null, NAME));
+        configuredOp.setContractName(reader.getAttributeValue(null, SERVICE));
+        configuredOp.setUnresolved(true);
+
+        // Read policies
+        policyProcessor.readPolicies(configuredOp, reader);
+
+        //Skip to end element
+        while (reader.hasNext()) {
+            if (reader.next() == END_ELEMENT && OPERATION_QNAME.equals(reader.getName())) {
+                break;
+            }
+        }
+
+        return configuredOp;
+    }
+
+    public void write(ConfiguredOperation configuredOperation, XMLStreamWriter writer)
+        throws ContributionWriteException, XMLStreamException {
+
+        // Write an <operation>
+        writer.writeStartElement(Constants.SCA10_NS, OPERATION);
+        policyProcessor.writePolicyAttributes(configuredOperation, writer);
+
+        writer.writeAttribute(NAME, configuredOperation.getName());
+        if ( configuredOperation.getContractName() != null ) {
+            writer.writeAttribute(SERVICE, configuredOperation.getContractName());
+        }
+        writer.writeEndElement();
+    }
+
+    public void resolve(ConfiguredOperation configuredOperation, ModelResolver resolver)
+        throws ContributionResolveException {
+    }
+
+    public QName getArtifactType() {
+        return OPERATION_QNAME;
+    }
+
+    public Class<ConfiguredOperation> getModelType() {
+        return ConfiguredOperation.class;
+    }
+
+}
+
+
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/Constants.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/Constants.java
new file mode 100644
index 0000000000..3bf5a1173b
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/Constants.java
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import javax.xml.namespace.QName;
+
+/**
+ * Constants used in SCA assembly XML files.
+ *
+ * @version $Rev$ $Date$
+ */
+public interface Constants {
+    String SCA10_NS = "http://www.osoa.org/xmlns/sca/1.0";
+    String SCA10_TUSCANY_NS = "http://tuscany.apache.org/xmlns/sca/1.0";
+    
+    String COMPONENT_TYPE = "componentType";
+    QName COMPONENT_TYPE_QNAME = new QName(SCA10_NS, COMPONENT_TYPE);
+    
+    String SERVICE = "service";
+    QName SERVICE_QNAME = new QName(SCA10_NS, SERVICE);
+    
+    String REFERENCE = "reference";
+    QName REFERENCE_QNAME = new QName(SCA10_NS, REFERENCE);
+    
+    String PROPERTY = "property";
+    QName PROPERTY_QNAME = new QName(SCA10_NS, PROPERTY);
+    
+    String CONSTRAINING_TYPE = "constrainingType";
+    QName CONSTRAINING_TYPE_QNAME = new QName(SCA10_NS, CONSTRAINING_TYPE);
+    
+    String COMPOSITE = "composite";
+    QName COMPOSITE_QNAME = new QName(SCA10_NS, COMPOSITE);
+    
+    String INCLUDE = "include";
+    QName INCLUDE_QNAME = new QName(SCA10_NS, INCLUDE); 
+    
+    String COMPONENT = "component";
+    QName COMPONENT_QNAME = new QName(SCA10_NS, COMPONENT);
+    
+    String WIRE = "wire";
+    QName WIRE_QNAME = new QName(SCA10_NS, WIRE);
+
+    String OPERATION = "operation";
+    QName OPERATION_QNAME = new QName(SCA10_NS, OPERATION);
+    
+    String CALLBACK = "callback";
+    QName CALLBACK_QNAME = new QName(SCA10_NS, CALLBACK);
+
+    String IMPLEMENTATION_COMPOSITE = "implementation.composite";
+    QName IMPLEMENTATION_COMPOSITE_QNAME = new QName(SCA10_NS, IMPLEMENTATION_COMPOSITE);
+    
+    String IMPLEMENTATION = "implementation";
+    QName IMPLEMENTATION_QNAME = new QName(SCA10_NS, IMPLEMENTATION);
+    
+    String BINDING_SCA = "binding.sca";
+    QName BINDING_SCA_QNAME = new QName(Constants.SCA10_NS, BINDING_SCA);
+    
+    String NAME = "name";
+    String TARGET_NAMESPACE = "targetNamespace";
+    String LOCAL = "local";
+    String AUTOWIRE = "autowire";
+    String REQUIRES = "requires";
+    String POLICY_SETS = "policySets"; 
+    String APPLICABLE_POLICY_SETS = "applicablePolicySets";
+    String PROMOTE = "promote";
+    String TARGET = "target";
+    String WIRED_BY_IMPL = "wiredByImpl";
+    String MULTIPLICITY = "multiplicity";
+    String TYPE = "type";
+    String ELEMENT = "element";
+    String MANY = "many";
+    String MUST_SUPPLY = "mustSupply";
+    String SOURCE = "source";
+    String FILE = "file";
+    String URI = "uri";
+    String ZERO_ONE = "0..1";
+    String ZERO_N = "0..n";
+    String ONE_ONE = "1..1";
+    String ONE_N = "1..n";
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConstrainingTypeDocumentProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConstrainingTypeDocumentProcessor.java
new file mode 100644
index 0000000000..9758d788f4
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConstrainingTypeDocumentProcessor.java
@@ -0,0 +1,144 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLConnection;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.ValidatingXMLInputFactory;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.monitor.Monitor;
+
+/**
+ * A contrainingType content handler.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ConstrainingTypeDocumentProcessor extends BaseAssemblyProcessor implements URLArtifactProcessor<ConstrainingType> {
+    private XMLInputFactory inputFactory;
+
+
+    /**
+     * Construct a new constrainingType processor.
+     * 
+     * @param staxProcessor
+     * @param inputFactory
+     * @param monitor
+     */
+    public ConstrainingTypeDocumentProcessor(StAXArtifactProcessor staxProcessor, 
+                                             XMLInputFactory inputFactory,
+                                             Monitor monitor) {
+        super(null, null, null, staxProcessor, null, monitor);
+        this.inputFactory = inputFactory;
+    }
+
+
+    /**
+     * Constructs a new constrainingType processor.
+     * @param modelFactories
+     * @param staxProcessor
+     * @param monitor
+     */
+    public ConstrainingTypeDocumentProcessor(ModelFactoryExtensionPoint modelFactories, 
+                                             StAXArtifactProcessor staxProcessor,
+                                             Monitor monitor) {
+        super(null, null, null, staxProcessor, null, monitor);
+        this.inputFactory = modelFactories.getFactory(ValidatingXMLInputFactory.class);
+    }
+    
+    public ConstrainingType read(URL contributionURL, URI uri, URL url) throws ContributionReadException {
+        InputStream urlStream = null;
+        try {
+            
+            // Create a stream reader
+            URLConnection connection = url.openConnection();
+            connection.setUseCaches(false);
+            urlStream = connection.getInputStream();
+            XMLStreamReader reader = inputFactory.createXMLStreamReader(url.toString(), urlStream);
+            reader.nextTag();
+            
+            // Read the constrainingType model 
+            ConstrainingType constrainingType = (ConstrainingType)extensionProcessor.read(reader);
+
+            // For debugging purposes, write it back to XML
+//            if (constrainingType != null) {
+//                try {
+//                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
+//                    XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
+//                    outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
+//                    extensionProcessor.write(constrainingType, outputFactory.createXMLStreamWriter(bos));
+//                    Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(bos.toByteArray()));
+//                    OutputFormat format = new OutputFormat();
+//                    format.setIndenting(true);
+//                    format.setIndent(2);
+//                    XMLSerializer serializer = new XMLSerializer(System.out, format);
+//                    serializer.serialize(document);
+//                } catch (Exception e) {
+//                    e.printStackTrace();
+//                }
+//            }
+            
+            return constrainingType;
+            
+        } catch (XMLStreamException e) {
+        	ContributionReadException ce = new ContributionReadException(e);
+        	error("ContributionReadException", inputFactory, ce);
+            throw ce;
+        } catch (IOException e) {
+        	ContributionReadException ce = new ContributionReadException(e);
+        	error("ContributionReadException", inputFactory, ce);
+            throw ce;
+        } finally {
+            try {
+                if (urlStream != null) {
+                    urlStream.close();
+                    urlStream = null;
+                }
+            } catch (IOException ioe) {
+                //ignore
+            }
+        }
+    }
+    
+    public void resolve(ConstrainingType constrainingType, ModelResolver resolver) throws ContributionResolveException {
+        extensionProcessor.resolve(constrainingType, resolver);
+    }
+    
+    public String getArtifactType() {
+        return ".constrainingType";
+    }
+    
+    public Class<ConstrainingType> getModelType() {
+        return ConstrainingType.class;
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConstrainingTypeModelResolver.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConstrainingTypeModelResolver.java
new file mode 100644
index 0000000000..7dd95e3944
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConstrainingTypeModelResolver.java
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.contribution.Contribution;
+import org.apache.tuscany.sca.contribution.Import;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.namespace.NamespaceImport;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+
+/**
+ * A Model Resolver for ConstrainingType models.
+ *
+ * @version $Rev$ $Date$
+ */
+public class ConstrainingTypeModelResolver implements ModelResolver {
+
+    private Contribution contribution;
+    private Map<QName, ConstrainingType> map = new HashMap<QName, ConstrainingType>();
+    
+    public ConstrainingTypeModelResolver(Contribution contribution, ModelFactoryExtensionPoint modelFactories) {
+        this.contribution = contribution;
+    }
+
+    public void addModel(Object resolved) {
+        ConstrainingType composite = (ConstrainingType)resolved;
+        map.put(composite.getName(), composite);
+    }
+    
+    public Object removeModel(Object resolved) {
+        return map.remove(((ConstrainingType)resolved).getName());
+    }
+    
+    public <T> T resolveModel(Class<T> modelClass, T unresolved) {
+        
+        // Lookup a definition for the given namespace
+        QName qname = ((ConstrainingType)unresolved).getName();
+        ConstrainingType resolved = (ConstrainingType) map.get(qname);
+        if (resolved != null) {
+            return modelClass.cast(resolved);
+        }
+        
+        // No definition found, delegate the resolution to the imports
+        for (Import import_ : this.contribution.getImports()) {
+            if (import_ instanceof NamespaceImport) {
+                NamespaceImport namespaceImport = (NamespaceImport)import_;
+                if (namespaceImport.getNamespace().equals(qname.getNamespaceURI())) {
+                    
+                    // Delegate the resolution to the import resolver
+                    resolved = namespaceImport.getModelResolver().resolveModel(ConstrainingType.class, (ConstrainingType)unresolved);
+                    if (!resolved.isUnresolved()) {
+                        return modelClass.cast(resolved);
+                    }
+                }
+            }
+        }
+        return (T)unresolved;
+    }
+    
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConstrainingTypeProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConstrainingTypeProcessor.java
new file mode 100644
index 0000000000..525ffd02e3
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConstrainingTypeProcessor.java
@@ -0,0 +1,292 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
+import static javax.xml.stream.XMLStreamConstants.START_ELEMENT;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.tuscany.sca.assembly.AbstractContract;
+import org.apache.tuscany.sca.assembly.AbstractProperty;
+import org.apache.tuscany.sca.assembly.AbstractReference;
+import org.apache.tuscany.sca.assembly.AbstractService;
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.assembly.ExtensionFactory;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXAttributeProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.impl.OperationImpl;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.w3c.dom.Document;
+
+/**
+ * A constrainingType processor.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ConstrainingTypeProcessor extends BaseAssemblyProcessor implements StAXArtifactProcessor<ConstrainingType> {
+
+    /**
+     * Construct a new constrainingType processor.
+     * @param assemblyFactory
+     * @param policyFactory
+     * @param extensionProcessor
+     */
+    public ConstrainingTypeProcessor(AssemblyFactory assemblyFactory,
+                                     ExtensionFactory extensionFactory,
+                                     PolicyFactory policyFactory, 
+                                     StAXArtifactProcessor extensionProcessor,
+                                     StAXAttributeProcessor extensionAttributeProcessor, 
+                                     Monitor monitor) {
+        super(assemblyFactory, extensionFactory, policyFactory, extensionProcessor, extensionAttributeProcessor, monitor);
+    }
+
+    /**
+     * Constructs a new constrainingType processor.
+     * 
+     * @param modelFactories
+     * @param extensionProcessor
+     */
+    public ConstrainingTypeProcessor(ModelFactoryExtensionPoint modelFactories, 
+                                     StAXArtifactProcessor extensionProcessor,
+                                     StAXAttributeProcessor extensionAttributeProcessor,
+                                     Monitor monitor) {
+        super(modelFactories.getFactory(AssemblyFactory.class),
+              modelFactories.getFactory(ExtensionFactory.class),
+              modelFactories.getFactory(PolicyFactory.class), 
+              extensionProcessor, 
+              extensionAttributeProcessor,
+              monitor);
+    }
+    
+    public ConstrainingType read(XMLStreamReader reader) throws ContributionReadException {
+        ConstrainingType constrainingType = null;
+        AbstractService abstractService = null;
+        AbstractReference abstractReference = null;
+        AbstractProperty abstractProperty = null;
+        AbstractContract abstractContract = null;
+        QName name = null;
+        
+        try {
+            // Read the constrainingType document
+            while (reader.hasNext()) {
+                int event = reader.getEventType();
+                switch (event) {
+    
+                    case START_ELEMENT:
+                        name = reader.getName();
+                        
+                        // Read a <constrainingType>
+                        if (Constants.CONSTRAINING_TYPE_QNAME.equals(name)) {
+                            constrainingType = assemblyFactory.createConstrainingType();
+                            constrainingType.setName(new QName(getString(reader, TARGET_NAMESPACE), getString(reader, NAME)));
+                            policyProcessor.readPolicies(constrainingType, reader);
+    
+                        } else if (Constants.SERVICE_QNAME.equals(name)) {
+                            
+                            // Read a <service>
+                            abstractService = assemblyFactory.createAbstractService();
+                            abstractContract = abstractService;
+                            abstractService.setName(getString(reader, Constants.NAME));
+                            constrainingType.getServices().add(abstractService);
+                            policyProcessor.readPolicies(abstractService, reader);
+    
+                        } else if (Constants.REFERENCE_QNAME.equals(name)) {
+                            
+                            // Read a <reference>
+                            abstractReference = assemblyFactory.createAbstractReference();
+                            abstractContract = abstractReference;
+                            abstractReference.setName(getString(reader, Constants.NAME));
+                            readMultiplicity(abstractReference, reader);
+                            constrainingType.getReferences().add(abstractReference);
+                            policyProcessor.readPolicies(abstractReference, reader);
+    
+                        } else if (Constants.PROPERTY_QNAME.equals(name)) {
+                            
+                            // Read a <property>
+                            abstractProperty = assemblyFactory.createAbstractProperty();
+                            readAbstractProperty(abstractProperty, reader);
+                            
+                            // Read the property value
+                            Document value = readPropertyValue(abstractProperty.getXSDElement(), abstractProperty.getXSDType(), reader);
+                            abstractProperty.setValue(value);
+                            
+                            constrainingType.getProperties().add(abstractProperty);
+                            policyProcessor.readPolicies(abstractProperty, reader);
+                            
+                        } else if (OPERATION_QNAME.equals(name)) {
+    
+                            // Read an <operation>
+                            Operation operation = new OperationImpl();
+                            operation.setName(getString(reader, NAME));
+                            operation.setUnresolved(true);
+                            policyProcessor.readPolicies(abstractContract, operation, reader);
+                            
+                        } else {
+    
+                            // Read an extension element
+                            Object extension = extensionProcessor.read(reader);
+                            if (extension instanceof InterfaceContract) {
+                                
+                                // <service><interface> and <reference><interface>
+                                abstractContract.setInterfaceContract((InterfaceContract)extension);
+                            } else {
+    
+                                // Add the extension element to the current element
+                                if (abstractContract != null) {
+                                    abstractContract.getExtensions().add(extension);
+                                } else {
+                                    constrainingType.getExtensions().add(extension);
+                                }
+                                
+                            }
+                        }
+                        break;
+    
+                    case END_ELEMENT:
+                        name = reader.getName();
+    
+                        // Clear current state when reading reaching end element
+                        if (SERVICE_QNAME.equals(name)) {
+                            abstractService = null;
+                            abstractContract = null;
+                        } else if (REFERENCE_QNAME.equals(name)) {
+                            abstractReference = null;
+                            abstractContract = null;
+                        } else if (PROPERTY_QNAME.equals(name)) {
+                            abstractProperty = null;
+                        }
+                        break;
+                }
+                if (reader.hasNext()) {
+                    reader.next();
+                }
+            }
+        }
+        catch (XMLStreamException e) {
+            ContributionReadException ex = new ContributionReadException(e);
+            error("XMLStreamException", reader, ex);
+        }
+        
+        return constrainingType;
+    }
+    
+    public void write(ConstrainingType constrainingType, XMLStreamWriter writer) throws ContributionWriteException, XMLStreamException {
+
+        // Write <constrainingType> element
+        writeStartDocument(writer, CONSTRAINING_TYPE,
+           new XAttr(TARGET_NAMESPACE, constrainingType.getName().getNamespaceURI()),
+           new XAttr(NAME, constrainingType.getName().getLocalPart()),
+           policyProcessor.writePolicies(constrainingType));
+
+        // Write <service> elements 
+        for (AbstractService service : constrainingType.getServices()) {
+            writeStart(writer, SERVICE, new XAttr(NAME, service.getName()),
+                       policyProcessor.writePolicies(service));
+            
+            extensionProcessor.write(service.getInterfaceContract(), writer);
+
+            for (Object extension: service.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            
+            writeEnd(writer);
+        }
+
+        // Write <reference> elements
+        for (AbstractReference reference : constrainingType.getReferences()) {
+            writeStart(writer, REFERENCE, new XAttr(NAME, reference.getName()),
+                       writeMultiplicity(reference),
+                       policyProcessor.writePolicies(reference));
+            
+            extensionProcessor.write(reference.getInterfaceContract(), writer);
+
+            for (Object extension: reference.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            
+            writeEnd(writer);
+        }
+
+        // Write <property> elements
+        for (AbstractProperty abstractProperty : constrainingType.getProperties()) {
+            writeStart(writer,
+                       PROPERTY,
+                       new XAttr(NAME, abstractProperty.getName()),
+                       new XAttr(MUST_SUPPLY, abstractProperty.isMustSupply()),
+                       new XAttr(MANY, abstractProperty.isMany()),
+                       new XAttr(TYPE, abstractProperty.getXSDType()),
+                       new XAttr(ELEMENT, abstractProperty.getXSDElement()),
+                       policyProcessor.writePolicies(abstractProperty));
+
+            // Write property value
+            writePropertyValue(abstractProperty.getValue(), abstractProperty.getXSDElement(), abstractProperty.getXSDType(), writer);
+
+            // Write extensions
+            for (Object extension : abstractProperty.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+
+            writeEnd(writer);
+        }
+
+        // Write extension elements
+        for (Object extension: constrainingType.getExtensions()) {
+            extensionProcessor.write(extension, writer);
+        }
+        
+        writeEndDocument(writer);
+    }
+    
+    public void resolve(ConstrainingType constrainingType, ModelResolver resolver) throws ContributionResolveException {
+        // Resolve component type services and references
+        resolveAbstractContracts(constrainingType.getServices(), resolver);
+        resolveAbstractContracts(constrainingType.getReferences(), resolver);
+        
+        resolveIntents(constrainingType.getRequiredIntents(), resolver);
+        for ( AbstractService service  : constrainingType.getServices() ) {
+            resolveIntents(service.getRequiredIntents(), resolver);
+        }
+        
+        for ( AbstractReference reference : constrainingType.getReferences() ) {
+            resolveIntents(reference.getRequiredIntents(), resolver);
+        }
+    }
+    
+    public QName getArtifactType() {
+        return CONSTRAINING_TYPE_QNAME;
+    }
+    
+    public Class<ConstrainingType> getModelType() {
+        return ConstrainingType.class;
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/DefaultBeanModelProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/DefaultBeanModelProcessor.java
new file mode 100644
index 0000000000..467ed37638
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/DefaultBeanModelProcessor.java
@@ -0,0 +1,258 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Base;
+import org.apache.tuscany.sca.assembly.ComponentType;
+import org.apache.tuscany.sca.assembly.ExtensionFactory;
+import org.apache.tuscany.sca.assembly.Implementation;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+
+/**
+ * Default Model Processor for beans.
+ *
+ * @version $Rev$ $Date$
+ */
+public class DefaultBeanModelProcessor<T> extends BaseAssemblyProcessor implements StAXArtifactProcessor<T> {
+
+    private QName artifactType;
+    private Class<T> modelClass;
+    private Object modelFactory;
+    private Method factoryMethod;
+    private Map<String, Method> setterMethods = new HashMap<String, Method>();
+    private Map<String, Method> getterMethods = new HashMap<String, Method>();
+
+    public DefaultBeanModelProcessor(AssemblyFactory assemblyFactory,
+    		                     ExtensionFactory extensionFactory,
+                                     PolicyFactory policyFactory,
+                                     QName artifactType,
+                                     Class<T> modelClass,
+                                     Object modelFactory,
+                                     Monitor monitor) {
+        super(assemblyFactory, extensionFactory, policyFactory, null, null, monitor);
+        this.artifactType = artifactType;
+        this.modelClass = modelClass;
+        this.modelFactory = modelFactory;
+
+        // Introspect the factory class and bean model class
+        if (modelFactory != null) {
+
+            // Find the model create method
+            for (Method method: modelFactory.getClass().getMethods()) {
+                if (method.getName().startsWith("create") && method.getReturnType() == modelClass) {
+                    factoryMethod = method;
+                    break;
+                }
+            }
+        }
+
+        // Index the bean's setter methods
+        for (Method method: modelClass.getMethods()) {
+            Method getter;
+            String name = method.getName();
+            if (name.startsWith("set") && name.length() > 3) {
+
+                // Get the corresponding getter method
+                try {
+                    getter = modelClass.getMethod("get" + name.substring(3));
+                } catch (Exception e) {
+                    getter = null;
+                    continue;
+                }
+
+                // Get the property name
+                name = name.substring(3);
+                if (name.length() > 1) {
+                    if (!name.toUpperCase().equals(name)) {
+                        name = name.substring(0, 1).toLowerCase() + name.substring(1);
+                    }
+                }
+            } else {
+                continue;
+            }
+
+            // Map an uppercase property name to a lowercase attribute name
+            if (name.toUpperCase().equals(name)) {
+                name = name.toLowerCase();
+            }
+
+            // Trim trailing _ from property names
+            if (name.endsWith("_")) {
+                name = name.substring(0, name.length()-1);
+            }
+            setterMethods.put(name, method);
+            getterMethods.put(name, getter);
+        }
+    }
+
+    public T read(XMLStreamReader reader) throws ContributionReadException, XMLStreamException {
+
+        // Read an element
+        try {
+
+            // Create a new instance of the model
+            Object model;
+            if (modelFactory != null) {
+                // Invoke the factory create method
+                model = factoryMethod.invoke(modelFactory);
+            } else {
+                // Invoke the model bean class default constructor
+                model = modelClass.newInstance();
+            }
+
+            // Initialize the bean properties with the attributes found in the
+            // XML element
+            for (int i = 0, n = reader.getAttributeCount(); i < n; i++) {
+                String attributeName = reader.getAttributeLocalName(i);
+                Method setter = setterMethods.get(attributeName);
+                if (setter != null) {
+                    String value = reader.getAttributeValue(i);
+                    setter.invoke(model, value);
+                }
+            }
+
+            // Read policies
+            policyProcessor.readPolicies(model, reader);
+
+            // FIXME read extension elements
+
+            // By default mark the model object unresolved
+            if (model instanceof Base) {
+                ((Base)model).setUnresolved(true);
+            }
+
+            // Skip to end element
+            while (reader.hasNext()) {
+                if (reader.next() == END_ELEMENT && artifactType.equals(reader.getName())) {
+                    break;
+                }
+            }
+            return (T) model;
+
+        } catch (Exception e) {
+        	ContributionReadException ce = new ContributionReadException(e);
+        	error("ContributionReadException", reader, ce);
+            throw ce;
+        }
+    }
+
+    public void write(T bean, XMLStreamWriter writer) throws ContributionWriteException, XMLStreamException {
+        try {
+            // Write the bean properties as attributes
+            List<XAttr> attrs = new ArrayList<XAttr>();
+            for (Map.Entry<String, Method> entry: getterMethods.entrySet()) {
+                if (entry.getValue().getReturnType() == String.class) {
+                    String value = (String)entry.getValue().invoke(bean);
+                    attrs.add(new XAttr(entry.getKey(), value));
+                }
+            }
+
+            // Write element
+            writeStart(writer, artifactType.getNamespaceURI(), artifactType.getLocalPart(),
+                       policyProcessor.writePolicies(bean), new XAttr(null, attrs));
+
+            writeEnd(writer);
+
+        } catch (Exception e) {
+        	ContributionWriteException ce = new ContributionWriteException(e);
+        	error("ContributionWriteException", writer, ce);
+            throw ce;
+        }
+    }
+
+    public void resolve(T bean, ModelResolver resolver) throws ContributionResolveException {
+
+        // Resolve and merge the component type associated with an
+        // implementation model
+        if (bean instanceof Implementation) {
+            Implementation implementation = (Implementation)bean;
+            String uri = implementation.getURI();
+            if (uri != null) {
+                int d = uri.lastIndexOf('.');
+                if (d != -1) {
+                    uri = uri.substring(0, d) + ".componentType";
+
+                    // Resolve the component type
+                    ComponentType componentType = assemblyFactory.createComponentType();
+                    componentType.setURI(uri);
+                    componentType.setUnresolved(true);
+
+                    componentType = resolver.resolveModel(ComponentType.class, componentType);
+                    if (componentType != null && !componentType.isUnresolved()) {
+
+                        // We found a component type, merge it into the implementation model
+                        implementation.getServices().addAll(componentType.getServices());
+                        implementation.getReferences().addAll(componentType.getReferences());
+                        implementation.getProperties().addAll(componentType.getProperties());
+                        implementation.setConstrainingType(componentType.getConstrainingType());
+
+                        if (implementation instanceof PolicySetAttachPoint &&
+                                componentType instanceof PolicySetAttachPoint ) {
+                            PolicySetAttachPoint policiedImpl = (PolicySetAttachPoint)implementation;
+                            PolicySetAttachPoint policiedCompType = (PolicySetAttachPoint)componentType;
+
+                            if ( policiedImpl.getPolicySets() != null) {
+                                policiedImpl.getPolicySets().addAll(policiedCompType.getPolicySets());
+                            }
+                            if (policiedImpl.getRequiredIntents() != null) {
+                                policiedImpl.getRequiredIntents().addAll(policiedCompType.getRequiredIntents());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Mark the model resolved
+        if (bean instanceof Base) {
+            ((Base)bean).setUnresolved(false);
+        }
+    }
+
+    public QName getArtifactType() {
+        return artifactType;
+    }
+
+    public Class<T> getModelType() {
+        return modelClass;
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/PolicyAttachPointProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/PolicyAttachPointProcessor.java
new file mode 100644
index 0000000000..44be1b6de1
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/PolicyAttachPointProcessor.java
@@ -0,0 +1,257 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.tuscany.sca.contribution.processor.BaseStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.policy.Intent;
+import org.apache.tuscany.sca.policy.IntentAttachPoint;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+
+/**
+ * A Policy Attach Point processor.
+ *
+ * @version $Rev$ $Date$
+ */
+public class PolicyAttachPointProcessor extends BaseStAXArtifactProcessor implements Constants {
+
+    private PolicyFactory policyFactory;
+
+    public PolicyAttachPointProcessor(PolicyFactory policyFactory) {
+        this.policyFactory = policyFactory;
+    }
+
+    /**
+     * Read policy intents associated with an operation.
+     * @param attachPoint
+     * @param operation
+     * @param reader
+     */
+    private void readIntents(Object attachPoint, Operation operation, XMLStreamReader reader) {
+        if (!(attachPoint instanceof IntentAttachPoint))
+            return;
+        IntentAttachPoint intentAttachPoint = (IntentAttachPoint)attachPoint;
+        String value = reader.getAttributeValue(null, REQUIRES);
+        if (value != null) {
+            List<Intent> requiredIntents = intentAttachPoint.getRequiredIntents();
+            for (StringTokenizer tokens = new StringTokenizer(value); tokens.hasMoreTokens();) {
+                QName qname = getQNameValue(reader, tokens.nextToken());
+                Intent intent = policyFactory.createIntent();
+                intent.setName(qname);
+                if (operation != null) {
+                    //FIXME Don't we need to handle intent specification
+                    // on an operation basis?
+                    //intent.getOperations().add(operation);
+                }
+                requiredIntents.add(intent);
+            }
+        }
+    }
+
+    /**
+     * Reads policy intents and policy sets associated with an operation.
+     * @param attachPoint
+     * @param operation
+     * @param reader
+     */
+    public void readPolicies(Object attachPoint, Operation operation, XMLStreamReader reader) {
+        readIntents(attachPoint, operation, reader);
+        readPolicySets(attachPoint, operation, reader);
+    }
+
+    /**
+     * Reads policy intents and policy sets.
+     * @param attachPoint
+     * @param reader
+     */
+    public void readPolicies(Object attachPoint, XMLStreamReader reader) {
+        readPolicies(attachPoint, null, reader);
+    }
+
+    /**
+     * Reads policy sets associated with an operation.
+     * @param attachPoint
+     * @param operation
+     * @param reader
+     */
+    private void readPolicySets(Object attachPoint, Operation operation, XMLStreamReader reader) {
+        if (!(attachPoint instanceof PolicySetAttachPoint)) {
+            return;
+        }
+        PolicySetAttachPoint policySetAttachPoint = (PolicySetAttachPoint)attachPoint;
+        String value = reader.getAttributeValue(null, POLICY_SETS);
+        if (value != null) {
+            List<PolicySet> policySets = policySetAttachPoint.getPolicySets();
+            for (StringTokenizer tokens = new StringTokenizer(value); tokens.hasMoreTokens();) {
+                QName qname = getQNameValue(reader, tokens.nextToken());
+                PolicySet policySet = policyFactory.createPolicySet();
+                policySet.setName(qname);
+                if (operation != null) {
+                    //FIXME Don't we need to handle policySet specification
+                    // on an operation basis?
+                    //policySet.getOperations().add(operation);
+                }
+                policySets.add(policySet);
+            }
+        }
+
+        value = reader.getAttributeValue(SCA10_TUSCANY_NS, APPLICABLE_POLICY_SETS);
+        if (value != null) {
+            List<PolicySet> applicablePolicySets = policySetAttachPoint.getApplicablePolicySets();
+            for (StringTokenizer tokens = new StringTokenizer(value); tokens.hasMoreTokens();) {
+                QName qname = getQNameValue(reader, tokens.nextToken());
+                PolicySet policySet = policyFactory.createPolicySet();
+                policySet.setName(qname);
+                if (operation != null) {
+                    //FIXME Don't we need to handle policySet specification
+                    // on an operation basis?
+                    //policySet.getOperations().add(operation);
+                }
+                applicablePolicySets.add(policySet);
+            }
+        }
+    }
+
+    /**
+     * Write policies
+     * @param attachPoint
+     * @return
+     */
+    XAttr writePolicies(Object attachPoint) throws XMLStreamException {
+        return writePolicies(attachPoint, (Operation)null);
+    }
+
+    /**
+     * Write policies
+     * @param attachPoint
+     * @return
+     */
+    public void writePolicyAttributes(Object attachPoint, XMLStreamWriter writer) throws XMLStreamException {
+        writePolicyAttributes(attachPoint, (Operation)null, writer);
+    }
+
+    /**
+     * Write policies associated with an operation
+     * @param attachPoint
+     * @param operation
+     * @return
+     */
+    XAttr writePolicies(Object attachPoint, Operation operation) {
+        List<XAttr> attrs =new ArrayList<XAttr>();
+        attrs.add(writeIntents(attachPoint, operation));
+        attrs.add(writePolicySets(attachPoint, operation));
+        return new XAttr(null, attrs);
+    }
+
+    /**
+     * Write policies
+     * @param attachPoint
+     * @return
+     */
+    public void writePolicyAttributes(Object attachPoint, Operation operation, XMLStreamWriter writer) throws XMLStreamException {
+        XAttr attr = writePolicies(attachPoint, operation);
+        attr.write(writer);
+    }
+
+    /**
+     * Write policies
+     * @param attachPoint
+     * @return
+     */
+    public void writePolicyPrefixes(Object attachPoint, Operation operation, XMLStreamWriter writer) throws XMLStreamException {
+        XAttr attr = writePolicies(attachPoint, operation);
+        attr.writePrefix(writer);
+    }
+
+    /**
+     * Write policy intents associated with an operation.
+     * @param attachPoint
+     * @param operation
+     */
+    private XAttr writeIntents(Object attachPoint, Operation operation) {
+        if (!(attachPoint instanceof IntentAttachPoint)) {
+            return null;
+        }
+        IntentAttachPoint intentAttachPoint = (IntentAttachPoint)attachPoint;
+        List<QName> qnames = new ArrayList<QName>();
+        for (Intent intent: intentAttachPoint.getRequiredIntents()) {
+            qnames.add(intent.getName());
+        }
+        return new XAttr(Constants.REQUIRES, qnames);
+    }
+
+    /**
+     * Write policy sets associated with an operation.
+     * @param attachPoint
+     * @param operation
+     */
+    private XAttr writePolicySets(Object attachPoint, Operation operation) {
+        if (!(attachPoint instanceof PolicySetAttachPoint)) {
+            return null;
+        }
+        PolicySetAttachPoint policySetAttachPoint = (PolicySetAttachPoint)attachPoint;
+        List<QName> qnames = new ArrayList<QName>();
+        for (PolicySet policySet: policySetAttachPoint.getPolicySets()) {
+            qnames.add(policySet.getName());
+        }
+        return new XAttr(Constants.POLICY_SETS, qnames);
+    }
+
+    public void resolvePolicies(Object attachPoint, ModelResolver resolver) {
+        if ( attachPoint instanceof PolicySetAttachPoint ) {
+            PolicySetAttachPoint policySetAttachPoint = (PolicySetAttachPoint)attachPoint;
+
+            List<Intent> requiredIntents = new ArrayList<Intent>();
+            Intent resolvedIntent = null;
+
+            if ( policySetAttachPoint.getRequiredIntents() != null && policySetAttachPoint.getRequiredIntents().size() > 0 ) {
+                for ( Intent intent : policySetAttachPoint.getRequiredIntents() ) {
+                    resolvedIntent = resolver.resolveModel(Intent.class, intent);
+                    requiredIntents.add(resolvedIntent);
+                }
+                policySetAttachPoint.getRequiredIntents().clear();
+                policySetAttachPoint.getRequiredIntents().addAll(requiredIntents);
+            }
+
+            if ( policySetAttachPoint.getPolicySets() != null && policySetAttachPoint.getPolicySets().size() > 0 ) {
+                List<PolicySet> resolvedPolicySets = new ArrayList<PolicySet>();
+                PolicySet resolvedPolicySet = null;
+                for ( PolicySet policySet : policySetAttachPoint.getPolicySets() ) {
+                    resolvedPolicySet = resolver.resolveModel(PolicySet.class, policySet);
+                    resolvedPolicySets.add(resolvedPolicySet);
+                }
+                policySetAttachPoint.getPolicySets().clear();
+                policySetAttachPoint.getPolicySets().addAll(resolvedPolicySets);
+            }
+        }
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor
new file mode 100644
index 0000000000..7a190dea9c
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor
@@ -0,0 +1,21 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License. 
+
+# Implementation class for the artifact processor extension
+org.apache.tuscany.sca.assembly.xml.ComponentTypeProcessor;qname=http://www.osoa.org/xmlns/sca/1.0#componentType,model=org.apache.tuscany.sca.assembly.ComponentType
+org.apache.tuscany.sca.assembly.xml.ConstrainingTypeProcessor;qname=http://www.osoa.org/xmlns/sca/1.0#constrainingType,model=org.apache.tuscany.sca.assembly.ConstrainingType
+org.apache.tuscany.sca.assembly.xml.CompositeProcessor;qname=http://www.osoa.org/xmlns/sca/1.0#composite,model=org.apache.tuscany.sca.assembly.Composite
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor
new file mode 100644
index 0000000000..403c049b48
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor
@@ -0,0 +1,21 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License. 
+
+# Implementation class for the artifact processor extension
+org.apache.tuscany.sca.assembly.xml.ComponentTypeDocumentProcessor;type=.componentType,model=org.apache.tuscany.sca.assembly.ComponentType
+org.apache.tuscany.sca.assembly.xml.ConstrainingTypeDocumentProcessor;type=.constrainingType,model=org.apache.tuscany.sca.assembly.ConstrainingType
+org.apache.tuscany.sca.assembly.xml.CompositeDocumentProcessor;type=.composite,model=org.apache.tuscany.sca.assembly.Composite
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.resolver.ModelResolver b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.resolver.ModelResolver
new file mode 100644
index 0000000000..ecc34942f1
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.resolver.ModelResolver
@@ -0,0 +1,20 @@
+# Licensed to the Apache Software Foundation (ASF) under one

+# or more contributor license agreements.  See the NOTICE file

+# distributed with this work for additional information

+# regarding copyright ownership.  The ASF licenses this file

+# to you under the Apache License, Version 2.0 (the

+# "License"); you may not use this file except in compliance

+# with the License.  You may obtain a copy of the License at

+# 

+#   http://www.apache.org/licenses/LICENSE-2.0

+# 

+# Unless required by applicable law or agreed to in writing,

+# software distributed under the License is distributed on an

+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+# KIND, either express or implied.  See the License for the

+# specific language governing permissions and limitations

+# under the License. 

+

+org.apache.tuscany.sca.assembly.xml.CompositeModelResolver;model=org.apache.tuscany.sca.assembly.Composite

+org.apache.tuscany.sca.assembly.xml.ConstrainingTypeModelResolver;model=org.apache.tuscany.sca.assembly.ConstrainingType

+org.apache.tuscany.sca.assembly.xml.ComponentTypeModelResolver;model=org.apache.tuscany.sca.assembly.ComponentType

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/assembly-xml-validation-messages.properties b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/assembly-xml-validation-messages.properties
new file mode 100644
index 0000000000..6fd524716c
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/main/resources/assembly-xml-validation-messages.properties
@@ -0,0 +1,30 @@
+#
+#
+#    Licensed to the Apache Software Foundation (ASF) under one
+#    or more contributor license agreements. See the NOTICE file
+#    distributed with this work for additional information
+#    regarding copyright ownership. The ASF licenses this file
+#    to you under the Apache License, Version 2.0 (the
+#    "License"); you may not use this file except in compliance
+#    with the License. You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing,
+#    software distributed under the License is distributed on an
+#    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#    KIND, either express or implied. See the License for the
+#    specific language governing permissions and limitations
+#    under the License.
+#
+#
+NoCompositeNamespace = No namespace found: Composite = {0}
+UnexpectedInterfaceElement = Unexpected <interface> element found. It should appear inside a <service> or <reference> element.
+UnexpectedBindingElement = Unexpected <binding> element found. It should appear inside a <service> or <reference> element.
+UnexpectedImplementationElement = Unexpected <implementation> element found. It should appear inside a <component> element.
+PolicyImplValidationException = PolicyValidation exception when processing implementation of component {0} due to {1}. 
+PolicyServiceValidationException = PolicyValidation exceptions when processing service/reference {0} in {1}. Error is {2}
+ContributionReadException = ContributionReadException occured due to : {0}
+ContributionWriteException = ContributionWriteException occured due to : {0}
+XMLStreamException = XMLStreamException occured due to : {0}
+HttpServerError = HTTP Server Error : {0}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/BuildPolicyTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/BuildPolicyTestCase.java
new file mode 100644
index 0000000000..5f8f976b84
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/BuildPolicyTestCase.java
@@ -0,0 +1,148 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.net.URI;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.namespace.QName;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.assembly.OperationsConfigurator;
+import org.apache.tuscany.sca.assembly.SCABindingFactory;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilder;
+import org.apache.tuscany.sca.assembly.builder.impl.CompositeBuilderImpl;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.DefaultURLArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleURLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.resolver.DefaultModelResolver;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.apache.tuscany.sca.core.UtilityExtensionPoint;
+import org.apache.tuscany.sca.definitions.SCADefinitions;
+import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper;
+import org.apache.tuscany.sca.interfacedef.impl.InterfaceContractMapperImpl;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.monitor.MonitorFactory;
+import org.apache.tuscany.sca.monitor.impl.DefaultMonitorFactoryImpl;
+import org.apache.tuscany.sca.policy.IntentAttachPoint;
+import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory;
+
+/**
+ * Test reading SCA XML assembly documents.
+ * 
+ * @version $Rev: 561254 $ $Date: 2007-07-31 13:16:27 +0530 (Tue, 31 Jul 2007) $
+ */
+public class BuildPolicyTestCase extends TestCase { 
+    private URLArtifactProcessor<Object> documentProcessor;
+    private URLArtifactProcessor<SCADefinitions> policyDefinitionsProcessor;
+    private ModelResolver resolver; 
+    private CompositeBuilder compositeBuilder;
+    private Composite composite;
+    private Monitor monitor;
+
+    @Override
+    public void setUp() throws Exception {
+        DefaultExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        ModelFactoryExtensionPoint modelFactories = extensionPoints.getExtensionPoint(ModelFactoryExtensionPoint.class);
+        AssemblyFactory assemblyFactory = modelFactories.getFactory(AssemblyFactory.class);
+        SCABindingFactory scaBindingFactory = new TestSCABindingFactoryImpl();
+        IntentAttachPointTypeFactory attachPointTypeFactory = modelFactories.getFactory(IntentAttachPointTypeFactory.class);
+        List<SCADefinitions> policyDefinitions = new ArrayList<SCADefinitions>();
+        resolver = new DefaultModelResolver();
+        
+        MonitorFactory monitorFactory = new DefaultMonitorFactoryImpl();
+        monitor = monitorFactory.createMonitor();
+        
+        UtilityExtensionPoint utilities = extensionPoints.getExtensionPoint(UtilityExtensionPoint.class);
+        InterfaceContractMapper mapper = utilities.getUtility(InterfaceContractMapper.class);
+        
+        compositeBuilder = new CompositeBuilderImpl(assemblyFactory, scaBindingFactory, attachPointTypeFactory, mapper, monitor);
+        URLArtifactProcessorExtensionPoint documentProcessors = new DefaultURLArtifactProcessorExtensionPoint(extensionPoints);
+        documentProcessor = new ExtensibleURLArtifactProcessor(documentProcessors, null);
+        policyDefinitionsProcessor = documentProcessors.getProcessor(SCADefinitions.class);
+        
+        StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        staxProcessors.addArtifactProcessor(new TestPolicyProcessor());
+        
+        URL url = getClass().getResource("CalculatorComponent.constrainingType");
+        URI uri = URI.create("CalculatorComponent.constrainingType");
+        ConstrainingType constrainingType = (ConstrainingType)documentProcessor.read(null, uri, url);
+        assertNotNull(constrainingType);
+        resolver.addModel(constrainingType);
+
+        url = getClass().getResource("TestAllPolicyCalculator.composite");
+        uri = URI.create("TestAllCalculator.constrainingType");
+        composite = (Composite)documentProcessor.read(null, uri, url);
+        assertNotNull(composite);
+        
+        url = getClass().getResource("another_test_definitions.xml");
+        uri = URI.create("another_test_definitions.xml");
+        SCADefinitions definitions = (SCADefinitions)policyDefinitionsProcessor.read(null, uri, url);
+        assertNotNull(definitions);
+        policyDefinitions.add(definitions);
+        
+        documentProcessor.resolve(definitions, resolver);
+        documentProcessor.resolve(composite, resolver);
+        
+        compositeBuilder.build(composite);
+    }
+
+    public void testPolicyIntentInheritance() throws Exception {
+        String namespaceUri = "http://test";
+        
+        IntentAttachPoint policiedComposite = (IntentAttachPoint)composite;
+        assertEquals(policiedComposite.getRequiredIntents().size(), 1);
+        assertEquals(policiedComposite.getRequiredIntents().get(0).getName(), new QName(namespaceUri, "tuscanyIntent_1"));
+        
+        //1 defined for composite, 2 defined for the service, 1 defined and 3 inherited for the promoted service (4)
+        assertEquals(composite.getServices().get(0).getRequiredIntents().size(), 7);
+        //1 from the operation defined in this service and 2 from the operation defined in the promoted service 
+        assertEquals(composite.getServices().get(0).getConfiguredOperations().get(0).getRequiredIntents().size(), 5);
+        assertEquals(composite.getServices().get(0).getRequiredIntents().get(3).getName(), new QName(namespaceUri, "tuscanyIntent_3"));
+        //bindings will have only 2 intents since duplications will be cut out
+        assertEquals(((IntentAttachPoint)composite.getServices().get(0).getBindings().get(0)).getRequiredIntents().size(), 3);
+        assertEquals(((OperationsConfigurator)composite.getServices().get(0).getBindings().get(0)).getConfiguredOperations().size(), 1);
+        assertEquals(((OperationsConfigurator)composite.getServices().get(0).getBindings().get(0)).getConfiguredOperations().get(0).getRequiredIntents().size(), 5);
+        
+        assertEquals(composite.getReferences().get(0).getRequiredIntents().size(), 5);
+        assertEquals(composite.getReferences().get(0).getConfiguredOperations().size(), 1);
+        assertEquals(composite.getReferences().get(0).getConfiguredOperations().get(0).getRequiredIntents().size(), 4);
+        assertEquals(composite.getReferences().get(0).getRequiredIntents().get(1).getName(), new QName(namespaceUri, "tuscanyIntent_1"));
+        assertEquals(((IntentAttachPoint)composite.getReferences().get(0).getBindings().get(0)).getRequiredIntents().size(), 3);
+
+        assertEquals(composite.getComponents().get(0).getRequiredIntents().size(), 3);
+        assertEquals(composite.getComponents().get(0).getRequiredIntents().get(2).getName(), new QName(namespaceUri, "tuscanyIntent_1"));
+        assertEquals(composite.getComponents().get(0).getServices().get(0).getRequiredIntents().size(), 4);
+        assertEquals(composite.getComponents().get(0).getServices().get(0).getCallback().getRequiredIntents().size(), 4);
+        assertEquals(composite.getComponents().get(0).getServices().get(0).getConfiguredOperations().get(0).getRequiredIntents().size(), 5);
+        assertEquals(composite.getComponents().get(0).getReferences().get(0).getRequiredIntents().size(), 5);
+        assertEquals(composite.getComponents().get(0).getReferences().get(0).getConfiguredOperations().get(0).getRequiredIntents().size(), 5);
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/MultiplicityReadWriteTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/MultiplicityReadWriteTestCase.java
new file mode 100644
index 0000000000..f34ff1f8bc
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/MultiplicityReadWriteTestCase.java
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */ 
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static junit.framework.Assert.assertEquals;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.Multiplicity;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Test writing SCA XML assemblies.
+ * 
+ * TUSCANY-2662
+ * 
+ * @version $Rev$ $Date$
+ */
+public class MultiplicityReadWriteTestCase {
+    private XMLInputFactory inputFactory;
+    private XMLOutputFactory outputFactory;
+    private ExtensibleStAXArtifactProcessor staxProcessor;
+
+
+    @Before
+    public void setUp() throws Exception {
+        DefaultExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        inputFactory = XMLInputFactory.newInstance();
+        outputFactory = XMLOutputFactory.newInstance();
+        StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        staxProcessor = new ExtensibleStAXArtifactProcessor(staxProcessors, inputFactory, outputFactory, null);
+    }
+
+
+    @Test
+    public void testReadWriteComposite() throws Exception {
+        InputStream is = getClass().getResourceAsStream("Multiplicity.composite");
+        Composite composite = staxProcessor.read(is, Composite.class);
+        
+        verifyComposite(composite);
+        
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        staxProcessor.write(composite, bos);
+        bos.close();
+        
+        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
+        composite = staxProcessor.read(bis, Composite.class);
+        
+        verifyComposite(composite);
+        
+    }
+
+    
+    private void verifyComposite(Composite composite) {
+        assertEquals(composite.getComponents().get(0).getReferences().get(0).getMultiplicity(), Multiplicity.ZERO_N);
+        assertEquals(composite.getReferences().get(0).getMultiplicity(), Multiplicity.ONE_N);
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadAllTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadAllTestCase.java
new file mode 100644
index 0000000000..e2aeb85d32
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadAllTestCase.java
@@ -0,0 +1,145 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.io.InputStream;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.assembly.Callback;
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.ComponentReference;
+import org.apache.tuscany.sca.assembly.ComponentService;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.CompositeReference;
+import org.apache.tuscany.sca.assembly.CompositeService;
+import org.apache.tuscany.sca.assembly.Property;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * Test reading SCA XML assemblies.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ReadAllTestCase extends TestCase {
+    private StAXArtifactProcessor<Object> staxProcessor;
+    private XMLInputFactory inputFactory;
+
+    @Override
+    public void setUp() throws Exception {
+        DefaultExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        inputFactory = XMLInputFactory.newInstance();
+        staxProcessor = new ExtensibleStAXArtifactProcessor(staxProcessors, inputFactory, null, null);
+    }
+
+    public void testReadComposite() throws Exception {
+        InputStream is = getClass().getResourceAsStream("TestAllCalculator.composite");
+        Composite composite = (Composite)staxProcessor.read(inputFactory.createXMLStreamReader(is));
+        assertNotNull(composite);
+        assertEquals(composite.getName(), new QName("http://calc", "TestAllCalculator"));
+        assertEquals(composite.getConstrainingType().getName(), new QName("http://calc", "CalculatorComponent"));
+        assertTrue(composite.isLocal());
+        assertFalse(composite.getAutowire() == Boolean.TRUE);
+        assertEquals(((PolicySetAttachPoint)composite).getRequiredIntents().get(0).getName(), new QName("http://test",
+                                                                                "confidentiality"));
+        assertEquals(((PolicySetAttachPoint)composite).getPolicySets().get(0).getName(), new QName("http://test", "SecureReliablePolicy"));
+
+        Composite include = composite.getIncludes().get(0);
+        assertEquals(include.getName(), new QName("http://calc", "TestAllDivide"));
+
+        CompositeService calcCompositeService = (CompositeService)composite.getServices().get(0);
+        assertEquals(calcCompositeService.getName(), "CalculatorService");
+        assertTrue(calcCompositeService.getPromotedService().isUnresolved());
+        assertEquals(calcCompositeService.getPromotedService().getName(),
+                     "CalculatorService");
+        assertEquals(calcCompositeService.getRequiredIntents().get(0).getName(),
+                     new QName("http://test", "confidentiality"));
+        assertEquals(calcCompositeService.getPolicySets().get(0).getName(), new QName("http://test", "SecureReliablePolicy"));
+        // TODO test operations
+        Callback calcServiceCallback = calcCompositeService.getCallback();
+        assertNotNull(calcServiceCallback);
+        assertEquals(calcServiceCallback.getRequiredIntents().get(0).getName(),
+                     new QName("http://test", "confidentiality"));
+        assertEquals(calcServiceCallback.getPolicySets().get(0).getName(), new QName("http://test", "SecureReliablePolicy"));
+        // TODO test operations
+
+        Component calcComponent = composite.getComponents().get(0);
+        assertEquals(calcComponent.getName(), "CalculatorServiceComponent");
+        assertEquals(calcComponent.getAutowire(), Boolean.FALSE);
+        assertEquals(calcComponent.getConstrainingType().getName(), new QName("http://calc",
+                                                                              "CalculatorComponent"));
+        assertEquals(calcComponent.getRequiredIntents().get(0).getName(), new QName("http://test",
+                                                                                    "confidentiality"));
+        assertEquals(calcComponent.getPolicySets().get(0).getName(), new QName("http://test", "SecureReliablePolicy"));
+
+        ComponentService calcComponentService = calcComponent.getServices().get(0);
+        assertEquals(calcComponentService.getName(), "CalculatorService");
+        assertEquals(calcComponentService.getRequiredIntents().get(0).getName(),
+                     new QName("http://test", "confidentiality"));
+        assertEquals(calcComponentService.getPolicySets().get(0).getName(), new QName("http://test", "SecureReliablePolicy"));
+        // TODO test operations
+
+        ComponentReference calcComponentReference = calcComponent.getReferences().get(0);
+        assertEquals(calcComponentReference.getName(), "addService");
+        assertEquals(calcComponentReference.getAutowire(), Boolean.FALSE);
+        assertEquals(calcComponentReference.isWiredByImpl(), false);
+        assertEquals(calcComponentReference.getRequiredIntents().get(0).getName(),
+                     new QName("http://test", "confidentiality"));
+        assertEquals(calcComponentReference.getPolicySets().get(0).getName(), new QName("http://test", "SecureReliablePolicy"));
+        // TODO test operations
+
+        Property property = calcComponent.getProperties().get(0);
+        assertEquals(property.getName(), "round");
+        Document doc = (Document) property.getValue();
+        Element element = doc.getDocumentElement();
+        String value = element.getTextContent();
+        assertEquals(value, "true");
+        assertEquals(property.getXSDType(), new QName("http://www.w3.org/2001/XMLSchema", "boolean"));
+        assertEquals(property.isMany(), false);
+
+        CompositeReference calcCompositeReference = (CompositeReference)composite.getReferences().get(0);
+        assertEquals(calcCompositeReference.getName(), "MultiplyService");
+        assertTrue(calcCompositeReference.getPromotedReferences().get(0).isUnresolved());
+        assertEquals(calcCompositeReference.getPromotedReferences().get(0).getName(),
+                     "CalculatorServiceComponent/multiplyService");
+        assertEquals(calcCompositeReference.getRequiredIntents().get(0).getName(),
+                     new QName("http://test", "confidentiality"));
+        assertEquals(calcCompositeReference.getPolicySets().get(0).getName(), new QName("http://test", "SecureReliablePolicy"));
+        // TODO test operations
+        Callback calcCallback = calcCompositeReference.getCallback();
+        assertEquals(calcCompositeReference.getRequiredIntents().get(0).getName(),
+                     new QName("http://test", "confidentiality"));
+        assertEquals(calcCompositeReference.getPolicySets().get(0).getName(), new QName("http://test", "SecureReliablePolicy"));
+        assertNotNull(calcCallback);
+        // TODO test operations
+
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadDocumentTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadDocumentTestCase.java
new file mode 100644
index 0000000000..b3760789c8
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadDocumentTestCase.java
@@ -0,0 +1,207 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.net.URI;
+import java.net.URL;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.SAXParserFactory;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.validation.Schema;
+import javax.xml.validation.SchemaFactory;
+import javax.xml.validation.ValidatorHandler;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.contribution.processor.DefaultValidatingXMLInputFactory;
+import org.apache.tuscany.sca.contribution.processor.DefaultValidationSchemaExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleURLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.ValidationSchemaExtensionPoint;
+import org.apache.tuscany.sca.contribution.resolver.DefaultModelResolver;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.xml.sax.InputSource;
+import org.xml.sax.XMLReader;
+
+/**
+ * Test reading SCA XML assembly documents.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ReadDocumentTestCase extends TestCase {
+
+    private URLArtifactProcessor<Object> documentProcessor;
+    private ModelResolver resolver;
+    private XMLInputFactory inputFactory;
+    private StAXArtifactProcessor<Object> staxProcessor; 
+
+    @Override
+    public void setUp() throws Exception {
+        DefaultExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        URLArtifactProcessorExtensionPoint documentProcessors = extensionPoints.getExtensionPoint(URLArtifactProcessorExtensionPoint.class);
+        documentProcessor = new ExtensibleURLArtifactProcessor(documentProcessors, null); 
+        
+        StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        inputFactory = XMLInputFactory.newInstance();
+        staxProcessor = new ExtensibleStAXArtifactProcessor(staxProcessors, inputFactory, null, null);
+        
+        resolver = new DefaultModelResolver();
+    }
+
+    public void testValidateAssembly() throws Exception {
+        
+        SchemaFactory schemaFactory;
+        try {
+            schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
+        } catch (Error e) {
+            // Some old JDKs don't support XMLSchema validation
+            return;
+        } catch (Exception e) {
+            // Some old JDKs don't support XMLSchema validation
+            return;
+        }
+        Schema schema = schemaFactory.newSchema(getClass().getClassLoader().getResource("tuscany-sca.xsd"));
+        ValidatorHandler handler = schema.newValidatorHandler();
+        
+        SAXParserFactory parserFactory = SAXParserFactory.newInstance();
+        URL url = getClass().getResource("Calculator.composite");
+        XMLReader reader = parserFactory.newSAXParser().getXMLReader();
+        reader.setFeature("http://xml.org/sax/features/namespaces", true);
+        reader.setContentHandler(handler);
+        reader.parse(new InputSource(url.openStream()));
+           
+    }
+
+    public void testValidateImplementation() throws Exception {
+        
+        SchemaFactory schemaFactory;
+        try {
+            schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
+        } catch (Error e) {
+            // Some old JDKs don't support XMLSchema validation
+            return;
+        } catch (Exception e) {
+            // Some old JDKs don't support XMLSchema validation
+            return;
+        }
+        Schema schema = schemaFactory.newSchema(getClass().getClassLoader().getResource("tuscany-sca.xsd"));
+        ValidatorHandler handler = schema.newValidatorHandler();
+        
+        SAXParserFactory parserFactory = SAXParserFactory.newInstance();
+        URL url = getClass().getResource("JavaScriptReference.composite");
+        XMLReader reader = parserFactory.newSAXParser().getXMLReader();
+        reader.setFeature("http://xml.org/sax/features/namespaces", true);
+        reader.setContentHandler(handler);
+        reader.parse(new InputSource(url.openStream()));
+    }
+        
+    public void testReadImplementation() throws Exception { 
+        
+        ValidationSchemaExtensionPoint schemas = new DefaultValidationSchemaExtensionPoint();
+        schemas.addSchema(getClass().getClassLoader().getResource("tuscany-sca.xsd").toString());
+        XMLInputFactory validatingInputFactory = new DefaultValidatingXMLInputFactory(inputFactory, schemas, null);
+        CompositeDocumentProcessor compositeDocumentProcessor = new CompositeDocumentProcessor(staxProcessor, validatingInputFactory, null, null);
+        
+        URL url = getClass().getResource("JavaScriptReference.composite");
+        URI uri = URI.create("JavaScriptReference.composite");
+        Composite composite = (Composite)compositeDocumentProcessor.read(null, uri, url);
+        assertNotNull(composite);
+    }
+        
+    public void testValidateBinding() throws Exception {
+        
+        SchemaFactory schemaFactory;
+        try {
+            schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
+        } catch (Error e) {
+            // Some old JDKs don't support XMLSchema validation
+            return;
+        } catch (Exception e) {
+            // Some old JDKs don't support XMLSchema validation
+            return;
+        }
+        Schema schema = schemaFactory.newSchema(getClass().getClassLoader().getResource("tuscany-sca.xsd"));
+        ValidatorHandler handler = schema.newValidatorHandler();
+        
+        SAXParserFactory parserFactory = SAXParserFactory.newInstance();
+        URL url = getClass().getResource("RMIBindingTest.composite");
+        XMLReader reader = parserFactory.newSAXParser().getXMLReader();
+        reader.setFeature("http://xml.org/sax/features/namespaces", true);
+        reader.setContentHandler(handler);
+        reader.parse(new InputSource(url.openStream()));
+    }
+        
+    public void testReadBinding() throws Exception {
+        
+        ValidationSchemaExtensionPoint schemas = new DefaultValidationSchemaExtensionPoint();
+        schemas.addSchema(getClass().getClassLoader().getResource("tuscany-sca.xsd").toString());
+        XMLInputFactory validatingInputFactory = new DefaultValidatingXMLInputFactory(inputFactory, schemas, null);
+        CompositeDocumentProcessor compositeDocumentProcessor = new CompositeDocumentProcessor(staxProcessor, validatingInputFactory, null, null);
+        
+        URL url = getClass().getResource("RMIBindingTest.composite");
+        URI uri = URI.create("RMIBindingTest.composite");
+        Composite composite = (Composite)compositeDocumentProcessor.read(null, uri, url);
+        assertNotNull(composite);
+    }
+        
+    public void testResolveConstrainingType() throws Exception {
+        
+        URL url = getClass().getResource("CalculatorComponent.constrainingType");
+        URI uri = URI.create("CalculatorComponent.constrainingType");
+        ConstrainingType constrainingType = (ConstrainingType)documentProcessor.read(null, uri, url);
+        assertNotNull(constrainingType);
+        resolver.addModel(constrainingType);
+
+        url = getClass().getResource("TestAllCalculator.composite");
+        uri = URI.create("TestAllCalculator.constrainingType");
+        Composite composite = (Composite)documentProcessor.read(null, uri, url);
+        assertNotNull(composite);
+        
+        documentProcessor.resolve(composite, resolver);
+        
+       assertEquals(composite.getConstrainingType(), constrainingType);
+        assertEquals(composite.getComponents().get(0).getConstrainingType(), constrainingType);
+    }
+
+    public void testResolveComposite() throws Exception {
+        URL url = getClass().getResource("Calculator.composite");
+        URI uri = URI.create("Calculator.composite");
+        Composite nestedComposite = (Composite)documentProcessor.read(null, uri, url);
+        assertNotNull(nestedComposite);
+        resolver.addModel(nestedComposite);
+
+        url = getClass().getResource("TestAllCalculator.composite");
+        uri = URI.create("TestAllCalculator.composite");
+        Composite composite = (Composite)documentProcessor.read(null, uri, url);
+        
+        documentProcessor.resolve(composite, resolver);
+        
+        assertEquals(composite.getComponents().get(2).getImplementation(), nestedComposite);
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadTestCase.java
new file mode 100644
index 0000000000..1aede413a5
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadTestCase.java
@@ -0,0 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.io.InputStream;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamReader;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+
+/**
+ * Test reading SCA XML assemblies.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ReadTestCase extends TestCase {
+
+    private XMLInputFactory inputFactory;
+    private StAXArtifactProcessor<Object> staxProcessor;
+
+    @Override
+    public void setUp() throws Exception {
+        ExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        inputFactory = XMLInputFactory.newInstance();
+        StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        staxProcessor = new ExtensibleStAXArtifactProcessor(staxProcessors, XMLInputFactory.newInstance(), XMLOutputFactory.newInstance(), null);
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+    }
+
+    public void testReadComponentType() throws Exception {
+        InputStream is = getClass().getResourceAsStream("CalculatorImpl.componentType");
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+        assertNotNull(staxProcessor.read(reader));
+        is.close();
+    }
+
+    public void testReadConstrainingType() throws Exception {
+        InputStream is = getClass().getResourceAsStream("CalculatorComponent.constrainingType");
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+        assertNotNull(staxProcessor.read(reader));
+        is.close();
+
+    }
+
+    public void testReadComposite() throws Exception {
+        InputStream is = getClass().getResourceAsStream("Calculator.composite");
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+        assertNotNull(staxProcessor.read(reader));
+        is.close();
+
+    }
+
+    public void testReadCompositeAndWireIt() throws Exception {
+        InputStream is = getClass().getResourceAsStream("Calculator.composite");
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+        assertNotNull(staxProcessor.read(reader));
+        is.close();
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadWriteAnyAttributeTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadWriteAnyAttributeTestCase.java
new file mode 100644
index 0000000000..200b7061c6
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadWriteAnyAttributeTestCase.java
@@ -0,0 +1,173 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.ByteArrayOutputStream;
+import java.io.StringReader;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXAttributeProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXAttributeProcessorExtensionPoint;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.junit.Test;
+
+/**
+ * Test reading SCA XML assemblies.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ReadWriteAnyAttributeTestCase {
+
+    private static final QName EXTENDED_ATTRIBUTE = new QName("http://test", "customAttribute");
+    
+    private static final String XML = "<?xml version='1.0' encoding='UTF-8'?>"+
+		 	 "<composite xmlns=\"http://www.osoa.org/xmlns/sca/1.0\" " +
+		 	            "xmlns:ns1=\"http://www.osoa.org/xmlns/sca/1.0\" " +
+		 	            "targetNamespace=\"http://calc\" " +
+		 	            "name=\"Calculator\">"+
+ 	 	 	    "<component name=\"AddServiceComponent\" xmlns:test=\"http://test\" test:customAttribute=\"customValue\">"+
+ 	 	 	      "<implementation.java class=\"calculator.AddServiceImpl\" />"+
+ 	 	 	    "</component>"+
+ 	 	 	  "</composite>";
+    
+    private static final String XML_WITH_EXTENDED_ATTRIBUTES_IN_BINDINGS = 
+        "<?xml version='1.0' encoding='UTF-8'?>" +
+        "<composite xmlns=\"http://www.osoa.org/xmlns/sca/1.0\" xmlns:ns1=\"http://www.osoa.org/xmlns/sca/1.0\" targetNamespace=\"http://temp\" name=\"myComposite\">" +
+          "<service name=\"service\">" +
+            "<interface.java interface=\"com.ibm.MyInterface\" xmlns:myPrefix=\"http://myPrefix\" myPrefix:myJavaInterfaceAnyAttribute=\"Java Interface Value\" />" +
+            "<binding.ws xmlns:myPrefix=\"http://myPrefix\" myPrefix:myWSAnyAttribute=\"WS Value\" />" + 
+            "<binding.ejb xmlns:myPrefix=\"http://myPrefix\" myPrefix:myEJBAnyAttribute=\"EJB Value\" />" +
+            "<binding.sca xmlns:myPrefix=\"http://myPrefix\" myPrefix:mySCAAnyAttribute=\"SCA Value\" />" +
+          "</service>" +
+          "<component name=\"component\">" +
+            "<implementation.java class=\"com.ibm.test.MyClass\" xmlns:myPrefix=\"http://myPrefix\" myPrefix:myJavaImplAnyAttribute=\"Java Impl Value\" />" +
+          "</component>" +
+          "<component name=\"component1\">" +
+             "<implementation.composite xmlns:ns2=\"http://temp\" name=\"ns2:myComposite\" xmlns:myPrefix=\"http://myPrefix\" myPrefix:myCompositeImplAnyAttribute=\"Composite Impl Value\" />" +
+          "</component>" +
+          "<reference name=\"reference\">" +
+             "<interface.wsdl interface=\"http://www.example.org/SpaceWarGame/#wsdl.interface(SpaceWarGame)\" xmlns:myPrefix=\"http://myPrefix\" myPrefix:myWSDLInterfaceAnyAttribute=\"WSDL Interface Value\" />" +
+          "</reference>" +
+          "</composite>";
+    
+    private XMLInputFactory inputFactory;
+    private ExtensibleStAXArtifactProcessor staxProcessor;
+
+
+    /**
+     * Initialize the test environment
+     * This takes care to register attribute processors when provided
+     *
+     * @param attributeProcessor
+     * @throws Exception
+     */
+    private void init(StAXAttributeProcessor<?> attributeProcessor) throws Exception {
+    	ExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+    	inputFactory = XMLInputFactory.newInstance();
+    	StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+
+    	if(attributeProcessor != null) {
+    		StAXAttributeProcessorExtensionPoint staxAttributeProcessors = extensionPoints.getExtensionPoint(StAXAttributeProcessorExtensionPoint.class);
+    		staxAttributeProcessors.addArtifactProcessor(attributeProcessor);
+    	}
+    	
+    	staxProcessor = new ExtensibleStAXArtifactProcessor(staxProcessors, XMLInputFactory.newInstance(), XMLOutputFactory.newInstance(), null);
+    }
+
+    /**
+     * Read and Write a composite that has a extended attribute
+     * and a particular attribute processor
+     * @throws Exception
+     */
+    @Test
+    public void testReadWriteCompositeWithAttributeProcessor() throws Exception {
+    	init(new TestAttributeProcessor());
+
+    	XMLStreamReader reader = inputFactory.createXMLStreamReader(new StringReader(XML));
+    	Composite composite = (Composite) staxProcessor.read(reader);
+    	assertNotNull(composite);
+    	reader.close();
+
+    	ByteArrayOutputStream bos = new ByteArrayOutputStream();
+    	staxProcessor.write(composite, bos);
+
+    	// used for debug comparison
+    	// System.out.println(XML);
+    	// System.out.println(bos.toString());
+
+    	assertEquals(XML, bos.toString());    	
+    }
+
+    /**
+     * Read and Write a composite that has a extended attribute
+     * but no particular processor for it
+     * @throws Exception
+     */
+    @Test
+    public void testDefaultReadWriteComposite() throws Exception {
+    	init(null);
+
+    	XMLStreamReader reader = inputFactory.createXMLStreamReader(new StringReader(XML));
+    	Composite composite = (Composite) staxProcessor.read(reader);
+    	assertNotNull(composite);
+    	reader.close();
+
+    	ByteArrayOutputStream bos = new ByteArrayOutputStream();
+    	staxProcessor.write(composite, bos);
+
+    	// used for debug comparison
+    	// System.out.println(XML);
+    	// System.out.println(bos.toString());
+
+    	assertEquals(XML, bos.toString());
+    }
+    
+
+    @Test
+    public void testReadWriteCompositeWithBindings() throws Exception {
+        init(null);
+        
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(new StringReader(XML_WITH_EXTENDED_ATTRIBUTES_IN_BINDINGS));
+        Composite composite = (Composite)staxProcessor.read(reader);
+        assertNotNull(composite);
+        reader.close();
+
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        staxProcessor.write(composite, bos);
+
+        // used for debug comparison
+        // System.out.println(XML_WITH_EXTENDED_ATTRIBUTES_IN_BINDINGS);
+        // System.out.println(bos.toString());
+
+        assertEquals(XML_WITH_EXTENDED_ATTRIBUTES_IN_BINDINGS, bos.toString());
+        bos.close();
+    }    
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadWriteAnyElementTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadWriteAnyElementTestCase.java
new file mode 100644
index 0000000000..e99f760e58
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadWriteAnyElementTestCase.java
@@ -0,0 +1,148 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.assembly.xml;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.ByteArrayOutputStream;
+import java.io.StringReader;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.ValidatingXMLInputFactory;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class ReadWriteAnyElementTestCase {
+    private static final String XML_RECURSIVE_EXTENDED_ELEMENT =
+        "<?xml version='1.0' encoding='UTF-8'?>" +
+        "<composite xmlns=\"http://www.osoa.org/xmlns/sca/1.0\" xmlns:ns1=\"http://www.osoa.org/xmlns/sca/1.0\" targetNamespace=\"http://temp\" name=\"RecursiveExtendedElement\">" +
+         "<unknownElement>" +
+           "<subUnknownElement1 attribute=\"anyAttribute\" />" +
+           "<subUnknownElement2 />" +
+         "</unknownElement>" +
+        "</composite>";
+
+    private static final String XML_UNKNOWN_IMPL =
+        "<?xml version='1.0' encoding='UTF-8'?>" + 
+        "<composite xmlns=\"http://www.osoa.org/xmlns/sca/1.0\" xmlns:ns1=\"http://www.osoa.org/xmlns/sca/1.0\" targetNamespace=\"http://temp\" name=\"aaaa\" autowire=\"false\">" +
+         "<component name=\"unknownImpl\">" +
+           "<implementation.unknown class=\"raymond\" />" +
+           "<service name=\"service\">" +
+             "<binding.ws name=\"wsName\" />" +
+             "<binding.new name=\"newName\" />" +
+           "</service>" +
+         "</component>" +
+        "</composite>";
+
+    private static final String XML_UNKNOWN_IMPL_WITH_INVALID_ATTRIBUTE =
+        "<?xml version='1.0' encoding='UTF-8'?>" + 
+        "<composite xmlns=\"http://www.osoa.org/xmlns/sca/1.0\" xmlns:ns1=\"http://www.osoa.org/xmlns/sca/1.0\" targetNamespace=\"http://temp\" name=\"aaaa\" autowire=\"false\">" +
+         "<component name=\"unknownImpl\">" +
+           "<implementation.unknown class=\"raymond\" />" +
+           "<service name=\"service\" requires=\"\">" +
+             "<binding.ws />" +
+           "</service>" +
+         "</component>" +
+        "</composite>";
+    
+    
+    private XMLInputFactory inputFactory;
+    private ExtensibleStAXArtifactProcessor staxProcessor;
+
+    @Before
+    public void setUp() throws Exception {
+        ExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        ModelFactoryExtensionPoint modelFactories = extensionPoints.getExtensionPoint(ModelFactoryExtensionPoint.class);
+        inputFactory = modelFactories.getFactory(ValidatingXMLInputFactory.class);
+
+        StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        staxProcessor = new ExtensibleStAXArtifactProcessor(staxProcessors, inputFactory, XMLOutputFactory.newInstance(), null);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+    }
+
+    @Test
+    public void testReadWriteExtendedRecursiveElement() throws Exception {
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(new StringReader(XML_RECURSIVE_EXTENDED_ELEMENT));
+        Composite composite = (Composite)staxProcessor.read(reader);
+        assertNotNull(composite);
+        reader.close();
+
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        staxProcessor.write(composite, bos);
+
+        // used for debug comparison
+        // System.out.println(XML_RECURSIVE_EXTENDED_ELEMENT);
+        // System.out.println(bos.toString());
+
+        assertEquals(XML_RECURSIVE_EXTENDED_ELEMENT, bos.toString());
+        bos.close();
+    }
+
+    @Test
+    public void testReadWriteUnknwonImpl() throws Exception {
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(new StringReader(XML_UNKNOWN_IMPL));
+        Composite composite = (Composite)staxProcessor.read(reader);
+        assertNotNull(composite);
+        reader.close();
+
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        staxProcessor.write(composite, bos);
+
+        // used for debug comparison
+        // System.out.println(XML_UNKNOWN_IMPL);
+        // System.out.println(bos.toString());
+
+        assertEquals(XML_UNKNOWN_IMPL, bos.toString());
+        bos.close();
+    }
+
+    // @Test
+    @Ignore()
+    public void testReadWriteInvalidAttribute() throws Exception {
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(new StringReader(XML_UNKNOWN_IMPL_WITH_INVALID_ATTRIBUTE));
+        Composite composite = (Composite)staxProcessor.read(reader);
+        assertNotNull(composite);
+        reader.close();
+
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        staxProcessor.write(composite, bos);
+
+        // used for debug comparison
+        // System.out.println(XML_UNKNOWN_IMPL);
+        // System.out.println(bos.toString());
+
+        assertEquals(XML_UNKNOWN_IMPL, bos.toString());
+        bos.close();
+    }
+}
\ No newline at end of file
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadWriteLocalCompositeTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadWriteLocalCompositeTestCase.java
new file mode 100644
index 0000000000..312b5c8fab
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ReadWriteLocalCompositeTestCase.java
@@ -0,0 +1,94 @@
+/*

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.    

+ */

+

+package org.apache.tuscany.sca.assembly.xml;

+

+import java.io.ByteArrayOutputStream;

+import java.io.InputStream;

+

+import javax.xml.namespace.QName;

+import javax.xml.stream.XMLInputFactory;

+import javax.xml.stream.XMLOutputFactory;

+import javax.xml.stream.XMLStreamReader;

+

+import junit.framework.TestCase;

+

+import org.apache.tuscany.sca.assembly.Composite;

+import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;

+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;

+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;

+import org.apache.tuscany.sca.contribution.processor.StAXAttributeProcessorExtensionPoint;

+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;

+import org.apache.tuscany.sca.core.ExtensionPointRegistry;

+

+/**

+ * Test reading SCA XML assemblies.

+ * 

+ * @version $Rev: 711584 $ $Date: 2008-11-05 15:07:03 +0000 (Wed, 05 Nov 2008) $

+ */

+public class ReadWriteLocalCompositeTestCase extends TestCase {

+

+    private XMLInputFactory inputFactory;

+    private ExtensibleStAXArtifactProcessor staxProcessor;

+

+    private static final String LOCAL_COMPOSITE_XML = "<?xml version='1.0' encoding='UTF-8'?>"+

+    "<composite xmlns=\"http://www.osoa.org/xmlns/sca/1.0\" xmlns:ns1=\"http://www.osoa.org/xmlns/sca/1.0\" targetNamespace=\"http://localcalc\" name=\"LocalCalculator\" local=\"true\">"+

+    "</composite>";

+    

+    @Override

+    public void setUp() throws Exception {

+        ExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();

+        inputFactory = XMLInputFactory.newInstance();

+        StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);

+

+        StAXAttributeProcessorExtensionPoint staxAttributeProcessors = extensionPoints.getExtensionPoint(StAXAttributeProcessorExtensionPoint.class);

+        staxAttributeProcessors.addArtifactProcessor(new TestAttributeProcessor());

+        

+        staxProcessor = new ExtensibleStAXArtifactProcessor(staxProcessors, XMLInputFactory.newInstance(), XMLOutputFactory.newInstance(), null);

+    }

+

+    @Override

+    public void tearDown() throws Exception {

+    	

+    }

+

+    public void testReadComposite() throws Exception {

+        InputStream is = getClass().getResourceAsStream("local.composite");

+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);

+        Composite composite = (Composite) staxProcessor.read(reader);

+        assertNotNull(composite);

+        assertTrue(composite.isLocal());

+        is.close();

+    }

+    

+    public void testWriteComposite() throws Exception {

+        InputStream is = getClass().getResourceAsStream("local.composite");

+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);

+        Composite composite = (Composite) staxProcessor.read(reader);

+        assertNotNull(composite);

+        assertTrue(composite.isLocal());

+        is.close();

+        

+        ByteArrayOutputStream bos = new ByteArrayOutputStream();

+        staxProcessor.write(composite, bos);

+        System.out.println(bos.toString());

+        

+        assertEquals(LOCAL_COMPOSITE_XML, bos.toString());

+    }

+}

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ResolvePolicyTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ResolvePolicyTestCase.java
new file mode 100644
index 0000000000..32a2d94220
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ResolvePolicyTestCase.java
@@ -0,0 +1,161 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml; 
+
+import java.net.URI;
+import java.net.URL;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleURLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.resolver.DefaultModelResolver;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.apache.tuscany.sca.definitions.SCADefinitions;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+
+/**
+ * Test reading SCA XML assembly documents.
+ * 
+ * @version $Rev: 561254 $ $Date: 2007-07-31 13:16:27 +0530 (Tue, 31 Jul 2007) $
+ */
+public class ResolvePolicyTestCase extends TestCase {
+
+    private URLArtifactProcessor<Object> documentProcessor;
+    private ModelResolver resolver;  
+    private URLArtifactProcessor<SCADefinitions> policyDefinitionsProcessor;
+
+    @Override
+    public void setUp() throws Exception {
+        DefaultExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        resolver = new DefaultModelResolver();
+        
+        URLArtifactProcessorExtensionPoint documentProcessors = extensionPoints.getExtensionPoint(URLArtifactProcessorExtensionPoint.class);
+        documentProcessor = new ExtensibleURLArtifactProcessor(documentProcessors, null);
+        policyDefinitionsProcessor = documentProcessors.getProcessor(SCADefinitions.class);
+        
+        // Create StAX processors
+        StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        staxProcessors.addArtifactProcessor(new TestPolicyProcessor());
+    }
+
+    public void testResolveConstrainingType() throws Exception {
+        
+        URL url = getClass().getResource("CalculatorComponent.constrainingType");
+        URI uri = URI.create("CalculatorComponent.constrainingType");
+        ConstrainingType constrainingType = (ConstrainingType)documentProcessor.read(null, uri, url);
+        assertNotNull(constrainingType);
+        resolver.addModel(constrainingType);
+
+        url = getClass().getResource("TestAllCalculator.composite");
+        uri = URI.create("TestAllCalculator.constrainingType");
+        Composite composite = (Composite)documentProcessor.read(null, uri, url);
+        assertNotNull(composite);
+        
+        url = getClass().getResource("test_definitions.xml");
+        uri = URI.create("test_definitions.xml");
+        SCADefinitions scaDefns = (SCADefinitions)policyDefinitionsProcessor.read(null, uri, url);
+        assertNotNull(scaDefns);
+        
+        preResolvePolicyTests(composite);
+        documentProcessor.resolve(scaDefns, resolver);
+        documentProcessor.resolve(composite, resolver);
+        postResolvePolicyTests(composite);
+        
+        assertEquals(composite.getConstrainingType(), constrainingType);
+        assertEquals(composite.getComponents().get(0).getConstrainingType(), constrainingType);
+    }
+    
+    private void preResolvePolicyTests(Composite composite) {
+        assertNull(((PolicySetAttachPoint)composite).getRequiredIntents().get(0).getDescription());
+        assertTrue(((PolicySetAttachPoint)composite).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        
+        assertNull(composite.getServices().get(0).getRequiredIntents().get(0).getDescription());
+        assertTrue(composite.getServices().get(0).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNull(composite.getServices().get(0).getCallback().getRequiredIntents().get(0).getDescription());
+        assertTrue(composite.getServices().get(0).getCallback().getPolicySets().get(0).getProvidedIntents().isEmpty());
+        
+        assertNull(composite.getComponents().get(0).getRequiredIntents().get(0).getDescription());
+        assertTrue(composite.getComponents().get(0).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNull(composite.getComponents().get(0).getServices().get(0).getRequiredIntents().get(0).getDescription());
+        assertTrue(composite.getComponents().get(0).getServices().get(0).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNull(composite.getComponents().get(0).getReferences().get(0).getRequiredIntents().get(0).getDescription());
+        assertTrue(composite.getComponents().get(0).getReferences().get(0).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        
+        assertNull(composite.getReferences().get(0).getRequiredIntents().get(0).getDescription());
+        assertTrue(composite.getReferences().get(0).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNull(composite.getReferences().get(0).getCallback().getRequiredIntents().get(0).getDescription());
+        assertTrue(composite.getReferences().get(0).getCallback().getPolicySets().get(0).getProvidedIntents().isEmpty());
+    }
+    
+    private void postResolvePolicyTests(Composite composite) {
+        assertNotNull(((PolicySetAttachPoint)composite).getRequiredIntents().get(0).getDescription());
+        assertFalse(((PolicySetAttachPoint)composite).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNotNull(((PolicySetAttachPoint)composite).getPolicySets().get(0).getProvidedIntents().get(1).getDescription());
+        
+        assertNotNull(composite.getServices().get(0).getRequiredIntents().get(0).getDescription());
+        assertFalse(composite.getServices().get(0).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNotNull(composite.getServices().get(0).getPolicySets().get(0).getProvidedIntents().get(1).getDescription());
+        assertNotNull(composite.getServices().get(0).getCallback().getRequiredIntents().get(0).getDescription());
+        assertFalse(composite.getServices().get(0).getCallback().getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNotNull(composite.getServices().get(0).getCallback().getPolicySets().get(0).getProvidedIntents().get(1).getDescription());
+        
+        assertNotNull(composite.getComponents().get(0).getRequiredIntents().get(0).getDescription());
+        assertFalse(composite.getComponents().get(0).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNotNull(composite.getComponents().get(0).getPolicySets().get(0).getProvidedIntents().get(1).getDescription());
+        assertNotNull(composite.getComponents().get(0).getServices().get(0).getRequiredIntents().get(0).getDescription());
+        assertFalse(composite.getComponents().get(0).getServices().get(0).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNotNull(composite.getComponents().get(0).getServices().get(0).getPolicySets().get(0).getProvidedIntents().get(1).getDescription());
+        assertNotNull(composite.getComponents().get(0).getReferences().get(0).getRequiredIntents().get(0).getDescription());
+        assertFalse(composite.getComponents().get(0).getReferences().get(0).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNotNull(composite.getComponents().get(0).getReferences().get(0).getPolicySets().get(0).getProvidedIntents().get(1).getDescription());
+        
+        assertNotNull(composite.getReferences().get(0).getRequiredIntents().get(0).getDescription());
+        assertFalse(composite.getReferences().get(0).getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNotNull(composite.getReferences().get(0).getPolicySets().get(0).getProvidedIntents().get(1).getDescription());
+        assertNotNull(composite.getReferences().get(0).getCallback().getRequiredIntents().get(0).getDescription());
+        assertFalse(composite.getReferences().get(0).getCallback().getPolicySets().get(0).getProvidedIntents().isEmpty());
+        assertNotNull(composite.getReferences().get(0).getCallback().getPolicySets().get(0).getProvidedIntents().get(1).getDescription());
+        
+        
+    }
+
+    public void testResolveComposite() throws Exception {
+        URL url = getClass().getResource("Calculator.composite");
+        URI uri = URI.create("Calculator.composite");
+        Composite nestedComposite = (Composite)documentProcessor.read(null, uri, url);
+        assertNotNull(nestedComposite);
+        resolver.addModel(nestedComposite);
+
+        url = getClass().getResource("TestAllCalculator.composite");
+        uri = URI.create("TestAllCalculator.composite");
+        Composite composite = (Composite)documentProcessor.read(null, uri, url);
+        
+        documentProcessor.resolve(composite, resolver);
+        
+        assertEquals(composite.getComponents().get(2).getImplementation(), nestedComposite);
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ResolveTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ResolveTestCase.java
new file mode 100644
index 0000000000..df09a56c38
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/ResolveTestCase.java
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.io.InputStream;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.resolver.DefaultModelResolver;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+
+/**
+ * Test resolving SCA XML assemblies.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ResolveTestCase extends TestCase {
+
+    private XMLInputFactory inputFactory;
+    private StAXArtifactProcessorExtensionPoint staxProcessors;
+    private ModelResolver resolver; 
+
+    @Override
+    public void setUp() throws Exception {
+        DefaultExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        inputFactory = XMLInputFactory.newInstance();
+        staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        resolver = new DefaultModelResolver();
+    }
+
+    public void testResolveConstrainingType() throws Exception {
+        InputStream is = getClass().getResourceAsStream("CalculatorComponent.constrainingType");
+        StAXArtifactProcessor<ConstrainingType> constrainingTypeReader = staxProcessors.getProcessor(ConstrainingType.class);
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+        ConstrainingType constrainingType = constrainingTypeReader.read(reader);
+        is.close();
+        assertNotNull(constrainingType);
+        resolver.addModel(constrainingType);
+
+        is = getClass().getResourceAsStream("TestAllCalculator.composite");
+        StAXArtifactProcessor<Composite> compositeReader = staxProcessors.getProcessor(Composite.class);
+        reader = inputFactory.createXMLStreamReader(is);
+        Composite composite = compositeReader.read(reader);
+        is.close();
+        assertNotNull(composite);
+        
+        compositeReader.resolve(composite, resolver);
+        
+        assertEquals(composite.getConstrainingType(), constrainingType);
+        assertEquals(composite.getComponents().get(0).getConstrainingType(), constrainingType);
+    }
+
+    public void testResolveComposite() throws Exception {
+        InputStream is = getClass().getResourceAsStream("Calculator.composite");
+        StAXArtifactProcessor<Composite> compositeReader = staxProcessors.getProcessor(Composite.class);
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+        Composite nestedComposite = compositeReader.read(reader);
+        is.close();
+        assertNotNull(nestedComposite);
+        resolver.addModel(nestedComposite);
+
+        is = getClass().getResourceAsStream("TestAllCalculator.composite");
+        reader = inputFactory.createXMLStreamReader(is);
+        Composite composite = compositeReader.read(reader);
+        is.close();
+        
+        compositeReader.resolve(composite, resolver);
+        
+        assertEquals(composite.getComponents().get(2).getImplementation(), nestedComposite);
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestAttributeProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestAttributeProcessor.java
new file mode 100644
index 0000000000..c34e9e3d22
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestAttributeProcessor.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.assembly.xml;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.tuscany.sca.contribution.processor.BaseStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXAttributeProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
+
+/**
+ * A Attribute Processor used for testing.
+ *
+ * @version $Rev$ $Date$
+ */
+public class TestAttributeProcessor extends BaseStAXArtifactProcessor implements StAXAttributeProcessor<String> {
+	private static final QName ATTRIBUTE = new QName("http://test", "customAttribute", "test");
+	
+    public QName getArtifactType() {
+        return ATTRIBUTE;
+    }
+
+    public String read(QName attributeName, XMLStreamReader reader) throws ContributionReadException, XMLStreamException {
+        return reader.getAttributeValue(attributeName.getNamespaceURI(), attributeName.getLocalPart());
+    }
+
+    public void write(String value, XMLStreamWriter writer) throws ContributionWriteException, XMLStreamException {
+    	writer.writeAttribute(ATTRIBUTE.getPrefix(), ATTRIBUTE.getNamespaceURI(),ATTRIBUTE.getLocalPart(), value);
+    } 
+
+    public Class<String> getModelType() {
+        return null;
+    }
+
+    public void resolve(String arg0, ModelResolver arg1) throws ContributionResolveException {
+    	
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestPolicyProcessor.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestPolicyProcessor.java
new file mode 100644
index 0000000000..16cefc58cf
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestPolicyProcessor.java
@@ -0,0 +1,73 @@
+/*

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.    

+ */

+package org.apache.tuscany.sca.assembly.xml;

+

+import javax.xml.namespace.QName;

+import javax.xml.stream.XMLStreamException;

+import javax.xml.stream.XMLStreamReader;

+import javax.xml.stream.XMLStreamWriter;

+

+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;

+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;

+import org.apache.tuscany.sca.contribution.service.ContributionReadException;

+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;

+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;

+import org.apache.tuscany.sca.policy.Policy;

+

+/**

+ * A Policy Processor used for testing.

+ *

+ * @version $Rev$ $Date$

+ */

+public class TestPolicyProcessor implements StAXArtifactProcessor<Policy> {

+

+    public QName getArtifactType() {

+        return new QName("http://schemas.xmlsoap.org/ws/2004/09/policy", "PolicyAttachment");

+    }

+

+    public Policy read(XMLStreamReader arg0) throws ContributionReadException, XMLStreamException {

+        return new MockPolicyImplOne();

+    }

+

+    public void write(Policy arg0, XMLStreamWriter arg1) throws ContributionWriteException,

+                                                        XMLStreamException {

+    } 

+

+    public Class<Policy> getModelType() {

+        return Policy.class;

+    }

+

+    public void resolve(Policy arg0, ModelResolver arg1) throws ContributionResolveException {

+    }

+

+    

+    public class MockPolicyImplOne implements Policy {

+        public QName getSchemaName() {

+            return new QName("http://schemas.xmlsoap.org/ws/2004/09/policy", "PolicyAttachment");

+        }

+

+        public boolean isUnresolved() {

+            return false;

+        }

+

+        public void setUnresolved(boolean unresolved) {

+        }

+        

+    }

+}

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestSCABindingFactoryImpl.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestSCABindingFactoryImpl.java
new file mode 100644
index 0000000000..c423df6f7d
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestSCABindingFactoryImpl.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import org.apache.tuscany.sca.assembly.SCABinding;
+import org.apache.tuscany.sca.assembly.SCABindingFactory;
+
+/**
+ * A factory for the SCA binding model.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class TestSCABindingFactoryImpl implements SCABindingFactory {
+    public SCABinding createSCABinding() {
+        return new TestSCABindingImpl();
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestSCABindingImpl.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestSCABindingImpl.java
new file mode 100644
index 0000000000..3046f2e630
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/TestSCABindingImpl.java
@@ -0,0 +1,214 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.ComponentService;
+import org.apache.tuscany.sca.assembly.ConfiguredOperation;
+import org.apache.tuscany.sca.assembly.OperationsConfigurator;
+import org.apache.tuscany.sca.assembly.OptimizableBinding;
+import org.apache.tuscany.sca.assembly.SCABinding;
+import org.apache.tuscany.sca.assembly.impl.ExtensibleImpl;
+import org.apache.tuscany.sca.policy.Intent;
+import org.apache.tuscany.sca.policy.IntentAttachPointType;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+
+/**
+ * A test cheel for the SCA binding.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class TestSCABindingImpl extends ExtensibleImpl implements SCABinding, OptimizableBinding, PolicySetAttachPoint, OperationsConfigurator {
+    private String name;
+    private String uri;
+    private List<Object> extensions = new ArrayList<Object>();
+    
+    private Component targetComponent;
+    private ComponentService targetComponentService;
+    private Binding targetBinding;
+    
+    private List<Intent> requiredIntents = new ArrayList<Intent>();
+    private List<PolicySet> policySets = new ArrayList<PolicySet>();
+    private IntentAttachPointType bindingType = new TestSCABindingType();
+    private List<ConfiguredOperation>  configuredOperations = new ArrayList<ConfiguredOperation>();
+    private List<PolicySet> applicablePolicySets = new ArrayList<PolicySet>();
+
+    /**
+     * Constructs a new SCA binding.
+     */
+    protected TestSCABindingImpl() {
+    }
+    
+    public String getName() {
+        return name;
+    }
+
+    public String getURI() {
+        return uri;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setURI(String uri) {
+        this.uri = uri;
+    }
+
+    public List<Object> getExtensions() {
+        return extensions;
+    }
+    
+    public boolean isUnresolved() {
+        return false;
+    }
+    
+    public void setUnresolved(boolean unresolved) {
+    }
+
+    /**
+     * @see java.lang.Object#clone()
+     */
+    @Override
+    public Object clone() throws CloneNotSupportedException {
+        return super.clone();
+    }
+
+    /**
+     * @return the targetComponent
+     */
+    public Component getTargetComponent() {
+        return targetComponent;
+    }
+
+    /**
+     * @param targetComponent the targetComponent to set
+     */
+    public void setTargetComponent(Component targetComponent) {
+        this.targetComponent = targetComponent;
+    }
+
+    /**
+     * @return the targetComponentService
+     */
+    public ComponentService getTargetComponentService() {
+        return targetComponentService;
+    }
+
+    /**
+     * @param targetComponentService the targetComponentService to set
+     */
+    public void setTargetComponentService(ComponentService targetComponentService) {
+        this.targetComponentService = targetComponentService;
+    }
+
+    /**
+     * @return the targetBinding
+     */
+    public Binding getTargetBinding() {
+        return targetBinding;
+    }
+
+    /**
+     * @param targetBinding the targetBinding to set
+     */
+    public void setTargetBinding(Binding targetBinding) {
+        this.targetBinding = targetBinding;
+    }
+    
+    public List<PolicySet> getPolicySets() {
+        // TODO Auto-generated method stub
+        return policySets;
+    }
+
+    public List<Intent> getRequiredIntents() {
+        // TODO Auto-generated method stub
+        return requiredIntents;
+    }
+
+    public IntentAttachPointType getType() {
+        // TODO Auto-generated method stub
+        return bindingType;
+    }
+
+    public void setType(IntentAttachPointType type) {
+        this.bindingType = type;
+    }
+    
+    private class TestSCABindingType implements IntentAttachPointType {
+        private QName name = new QName("http://www.osoa.org/xmlns/sca/1.0","binding");
+
+        public List<Intent> getAlwaysProvidedIntents() {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public List<Intent> getMayProvideIntents() {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public QName getName() {
+            return name;
+        }
+
+        public boolean isUnresolved() {
+            // TODO Auto-generated method stub
+            return false;
+        }
+
+        public void setName(QName type) {
+            // TODO Auto-generated method stub
+            
+        }
+
+        public void setUnresolved(boolean unresolved) {
+            // TODO Auto-generated method stub
+            
+        }
+        
+    }
+    
+    public void setPolicySets(List<PolicySet> policySets) {
+        this.policySets = policySets; 
+    }
+
+    public void setRequiredIntents(List<Intent> intents) {
+        this.requiredIntents = intents;
+    }
+    
+    public List<ConfiguredOperation> getConfiguredOperations() {
+        return configuredOperations;
+    }
+
+    public void setConfiguredOperations(List<ConfiguredOperation> configuredOperations) {
+        this.configuredOperations = configuredOperations;
+    }
+
+    public List<PolicySet> getApplicablePolicySets() {
+        return applicablePolicySets;
+    }
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/WireTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/WireTestCase.java
new file mode 100644
index 0000000000..76361d4b70
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/WireTestCase.java
@@ -0,0 +1,147 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URL;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.assembly.SCABindingFactory;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilder;
+import org.apache.tuscany.sca.assembly.builder.impl.CompositeBuilderImpl;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.resolver.DefaultModelResolver;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.apache.tuscany.sca.core.UtilityExtensionPoint;
+import org.apache.tuscany.sca.definitions.SCADefinitions;
+import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper;
+import org.apache.tuscany.sca.interfacedef.impl.InterfaceContractMapperImpl;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.monitor.MonitorFactory;
+import org.apache.tuscany.sca.monitor.impl.DefaultMonitorFactoryImpl;
+import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory;
+
+/**
+ * Test the wiring of SCA XML assemblies.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class WireTestCase extends TestCase {
+
+    private XMLInputFactory inputFactory;
+    private StAXArtifactProcessor<Object> staxProcessor;
+    private ModelResolver resolver; 
+    private URLArtifactProcessor<SCADefinitions> policyDefinitionsProcessor;
+    private CompositeBuilder compositeBuilder;
+    private Monitor monitor;
+
+    @Override
+    public void setUp() throws Exception {
+        DefaultExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        inputFactory = XMLInputFactory.newInstance();
+        StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        staxProcessor = new ExtensibleStAXArtifactProcessor(staxProcessors, inputFactory, null, null);
+        resolver = new DefaultModelResolver();
+        
+        MonitorFactory monitorFactory = new DefaultMonitorFactoryImpl();
+        monitor = monitorFactory.createMonitor();
+        
+        ModelFactoryExtensionPoint modelFactories = extensionPoints.getExtensionPoint(ModelFactoryExtensionPoint.class);
+        AssemblyFactory assemblyFactory = modelFactories.getFactory(AssemblyFactory.class);
+        SCABindingFactory scaBindingFactory = new TestSCABindingFactoryImpl();
+        IntentAttachPointTypeFactory attachPointTypeFactory = modelFactories.getFactory(IntentAttachPointTypeFactory.class);
+
+        UtilityExtensionPoint utilities = extensionPoints.getExtensionPoint(UtilityExtensionPoint.class);
+        InterfaceContractMapper mapper = utilities.getUtility(InterfaceContractMapper.class);
+        compositeBuilder = new CompositeBuilderImpl(assemblyFactory, scaBindingFactory, attachPointTypeFactory, mapper, monitor);
+
+        URLArtifactProcessorExtensionPoint documentProcessors = extensionPoints.getExtensionPoint(URLArtifactProcessorExtensionPoint.class);
+        policyDefinitionsProcessor = documentProcessors.getProcessor(SCADefinitions.class);
+    }
+
+    public void testResolveConstrainingType() throws Exception {
+        InputStream is = getClass().getResourceAsStream("CalculatorComponent.constrainingType");
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+        ConstrainingType constrainingType = (ConstrainingType)staxProcessor.read(reader);
+        is.close();
+        assertNotNull(constrainingType);
+        resolver.addModel(constrainingType);
+
+        is = getClass().getResourceAsStream("TestAllCalculator.composite");
+        reader = inputFactory.createXMLStreamReader(is);
+        Composite composite = (Composite)staxProcessor.read(reader);
+        is.close();
+        assertNotNull(composite);
+        
+        URL url = getClass().getResource("test_definitions.xml");
+        URI uri = URI.create("test_definitions.xml");
+        SCADefinitions scaDefns = (SCADefinitions)policyDefinitionsProcessor.read(null, uri, url);
+        assertNotNull(scaDefns);
+        
+        policyDefinitionsProcessor.resolve(scaDefns, resolver);
+        
+        staxProcessor.resolve(composite, resolver);
+        compositeBuilder.build(composite);
+        
+        assertEquals(composite.getConstrainingType(), constrainingType);
+        assertEquals(composite.getComponents().get(0).getConstrainingType(), constrainingType);
+    }
+
+    public void testResolveComposite() throws Exception {
+        InputStream is = getClass().getResourceAsStream("Calculator.composite");
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+        Composite nestedComposite = (Composite)staxProcessor.read(reader);
+        is.close();
+        assertNotNull(nestedComposite);
+        resolver.addModel(nestedComposite);
+
+        is = getClass().getResourceAsStream("TestAllCalculator.composite");
+        reader = inputFactory.createXMLStreamReader(is);
+        Composite composite = (Composite)staxProcessor.read(reader);
+        is.close();
+        
+        URL url = getClass().getResource("test_definitions.xml");
+        URI uri = URI.create("test_definitions.xml");
+        SCADefinitions scaDefns = (SCADefinitions)policyDefinitionsProcessor.read(null, uri, url);
+        assertNotNull(scaDefns);
+        
+        policyDefinitionsProcessor.resolve(scaDefns, resolver);
+        
+        staxProcessor.resolve(composite, resolver);
+        compositeBuilder.build(composite);
+        
+        assertEquals(composite.getComponents().get(2).getImplementation(), nestedComposite);
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/WriteAllTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/WriteAllTestCase.java
new file mode 100644
index 0000000000..b859779437
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/WriteAllTestCase.java
@@ -0,0 +1,160 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */ 
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URL;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.ComponentType;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.assembly.SCABindingFactory;
+import org.apache.tuscany.sca.assembly.builder.CompositeBuilder;
+import org.apache.tuscany.sca.assembly.builder.impl.CompositeBuilderImpl;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.contribution.resolver.DefaultModelResolver;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.apache.tuscany.sca.core.UtilityExtensionPoint;
+import org.apache.tuscany.sca.definitions.SCADefinitions;
+import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper;
+import org.apache.tuscany.sca.interfacedef.impl.InterfaceContractMapperImpl;
+import org.apache.tuscany.sca.monitor.Monitor;
+import org.apache.tuscany.sca.monitor.MonitorFactory;
+import org.apache.tuscany.sca.monitor.impl.DefaultMonitorFactoryImpl;
+import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory;
+
+/**
+ * Test writing SCA XML assemblies.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class WriteAllTestCase extends TestCase {
+    private XMLInputFactory inputFactory;
+    private XMLOutputFactory outputFactory;
+    private ExtensibleStAXArtifactProcessor staxProcessor;
+    private ModelResolver resolver; 
+    private CompositeBuilder compositeBuilder;
+    private URLArtifactProcessor<SCADefinitions> policyDefinitionsProcessor;
+    private Monitor monitor;
+
+    @Override
+    public void setUp() throws Exception {
+        DefaultExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        inputFactory = XMLInputFactory.newInstance();
+        outputFactory = XMLOutputFactory.newInstance();
+        StAXArtifactProcessorExtensionPoint staxProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        staxProcessor = new ExtensibleStAXArtifactProcessor(staxProcessors, inputFactory, outputFactory, null);
+        resolver = new DefaultModelResolver();
+        
+        ModelFactoryExtensionPoint modelFactories = extensionPoints.getExtensionPoint(ModelFactoryExtensionPoint.class);
+        AssemblyFactory assemblyFactory = modelFactories.getFactory(AssemblyFactory.class);
+        SCABindingFactory scaBindingFactory = new TestSCABindingFactoryImpl();
+        IntentAttachPointTypeFactory attachPointTypeFactory = modelFactories.getFactory(IntentAttachPointTypeFactory.class);
+
+        UtilityExtensionPoint utilities = extensionPoints.getExtensionPoint(UtilityExtensionPoint.class);
+        InterfaceContractMapper mapper = utilities.getUtility(InterfaceContractMapper.class);
+        
+        MonitorFactory monitorFactory = new DefaultMonitorFactoryImpl();
+        monitor = monitorFactory.createMonitor();
+        
+        compositeBuilder = new CompositeBuilderImpl(assemblyFactory, scaBindingFactory, attachPointTypeFactory, mapper, monitor);
+
+        URLArtifactProcessorExtensionPoint documentProcessors = extensionPoints.getExtensionPoint(URLArtifactProcessorExtensionPoint.class);
+        policyDefinitionsProcessor = documentProcessors.getProcessor(SCADefinitions.class);
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+    }
+
+    public void testReadWriteComposite() throws Exception {
+        InputStream is = getClass().getResourceAsStream("TestAllCalculator.composite");
+        Composite composite = staxProcessor.read(is, Composite.class);
+        
+        verifyComposite(composite);
+        
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        staxProcessor.write(composite, bos);
+        bos.close();
+        
+        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
+        composite = staxProcessor.read(bis, Composite.class);
+        
+        verifyComposite(composite);
+        
+    }
+
+    public void testReadWireWriteComposite() throws Exception {
+        InputStream is = getClass().getResourceAsStream("TestAllCalculator.composite");
+        Composite composite = staxProcessor.read(is, Composite.class);
+        
+        URL url = getClass().getResource("test_definitions.xml");
+        URI uri = URI.create("test_definitions.xml");
+        SCADefinitions scaDefns = (SCADefinitions)policyDefinitionsProcessor.read(null, uri, url);
+        assertNotNull(scaDefns);
+        policyDefinitionsProcessor.resolve(scaDefns, resolver);
+        
+        staxProcessor.resolve(composite, resolver);
+        compositeBuilder.build(composite);
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        staxProcessor.write(composite, bos);
+    }
+    
+    public void testReadWriteComponentType() throws Exception {
+        InputStream is = getClass().getResourceAsStream("CalculatorImpl.componentType");
+        ComponentType componentType = staxProcessor.read(is, ComponentType.class);
+        staxProcessor.resolve(componentType, resolver);
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        staxProcessor.write(componentType, bos);
+    }
+
+    public void testReadWriteConstrainingType() throws Exception {
+        InputStream is = getClass().getResourceAsStream("CalculatorComponent.constrainingType");
+        ConstrainingType constrainingType = staxProcessor.read(is, ConstrainingType.class);
+        staxProcessor.resolve(constrainingType, resolver);
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        staxProcessor.write(constrainingType, bos);
+    }
+    
+    private void verifyComposite(Composite composite) {
+        assertEquals(composite.getProperties().get(0).getName(),"prop1");
+        assertEquals(composite.getProperties().get(0).isMany(), true);
+        assertEquals(composite.getProperties().get(1).getName(),"prop2");
+        assertEquals(composite.getProperties().get(1).isMustSupply(), true);
+        assertEquals(composite.getProperties().get(0).getXSDType(), new QName("http://foo", "MyComplexType"));
+        assertEquals(composite.getProperties().get(1).getXSDElement(), new QName("http://www.osoa.org/xmlns/sca/1.0", "MyComplexPropertyValue1"));
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/WriteNamespacesTestCase.java b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/WriteNamespacesTestCase.java
new file mode 100644
index 0000000000..5188b1c91a
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/java/org/apache/tuscany/sca/assembly/xml/WriteNamespacesTestCase.java
@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */ 
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import junit.framework.TestCase;
+
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
+import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+
+/**
+ * Test writing SCA XML assemblies.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class WriteNamespacesTestCase extends TestCase {
+    private StAXArtifactProcessor<Composite> compositeProcessor;
+    private XMLOutputFactory outputFactory;
+    private XMLInputFactory inputFactory;
+
+    @Override
+    public void setUp() throws Exception {
+        ExtensionPointRegistry extensionPoints = new DefaultExtensionPointRegistry();
+        ModelFactoryExtensionPoint modelFactories = extensionPoints.getExtensionPoint(ModelFactoryExtensionPoint.class);
+        outputFactory = modelFactories.getFactory(XMLOutputFactory.class);
+        //outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
+        inputFactory = modelFactories.getFactory(XMLInputFactory.class);
+        
+        StAXArtifactProcessorExtensionPoint artifactProcessors = extensionPoints.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
+        compositeProcessor = artifactProcessors.getProcessor(Composite.class);
+    }
+
+    public void testReadWriteComposite() throws Exception {
+        
+        // Read
+        InputStream is = getClass().getResourceAsStream("NestedCalculator.composite");
+        XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+        Composite composite = compositeProcessor.read(reader);
+        Component component = composite.getComponents().get(0);
+        Composite implementation = (Composite)component.getImplementation();
+        QName qname = implementation.getName();
+
+        // Write
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        XMLStreamWriter writer = outputFactory.createXMLStreamWriter(bos);
+        compositeProcessor.write(composite, writer);
+        System.out.println(bos);
+        
+        // Read again
+        is = new ByteArrayInputStream(bos.toByteArray());
+        reader = inputFactory.createXMLStreamReader(is);
+        composite = compositeProcessor.read(reader);
+        
+        // Compare
+        component = composite.getComponents().get(0);
+        implementation = (Composite)component.getImplementation();
+        assertEquals(qname, implementation.getName());
+    }
+
+}
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/Calculator.composite b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/Calculator.composite
new file mode 100644
index 0000000000..602d42a06a
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/Calculator.composite
@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<!--

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.    

+-->

+<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"

+	xmlns:x="http://x"

+	xmlns:calc="http://calc"
+	targetNamespace="http://calc"

+	name="Calculator">

+	

+	<service name="CalculatorService" promote="CalculatorServiceComponent">

+        <interface.java interface="calculator.CalculatorService"/>

+    </service>

+    

+    <component name="CalculatorServiceComponent">

+		<implementation.java class="calculator.CalculatorServiceImpl"/>

+        <reference name="addService"  multiplicity="0..1" target="AddServiceComponent"/>

+        <reference name="subtractService" target="SubtractServiceComponent"/>

+        <reference name="multiplyService" target="MultiplyServiceComponent"/>

+        <reference name="divideService" target="DivideServiceComponent"/>

+    </component>

+

+    <component name="AddServiceComponent">

+        <implementation.java class="calculator.AddServiceImpl"/>

+    </component>

+

+    <component name="SubtractServiceComponent">

+        <implementation.java class="calculator.SubtractServiceImpl"/>

+    </component>

+

+    <component name="MultiplyServiceComponent">

+        <implementation.java class="calculator.MultiplyServiceImpl"/>

+    </component>

+

+    <component name="DivideServiceComponent">

+        <implementation.java class="calculator.DivideServiceImpl"/>

+    </component>

+    

+    <x:unknownElement uknAttr="attribute1">

+		<y:subUnknownElement1 xmlns:y="http://y" uknAttr1="attribute2"/>

+		<x:subUnknownElement2 />

+	</x:unknownElement>

+		

+</composite>

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/CalculatorComponent.constrainingType b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/CalculatorComponent.constrainingType
new file mode 100644
index 0000000000..d6ec9b0ff0
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/CalculatorComponent.constrainingType
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="ASCII"?>
+<!--
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+-->
+<constrainingType xmlns="http://www.osoa.org/xmlns/sca/1.0"
+	xmlns:calc="http://calc"
+	targetNamespace="http://calc"
+	name="CalculatorComponent">
+
+  <service name="CalculatorService">
+        <interface.java class="calculator.CalculatorService" />
+  </service>
+
+  <reference name="divideService" multiplicity="1..1">
+        <interface.java class="calculator.DivideService" />
+  </reference>  
+
+</constrainingType>              
+       
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/CalculatorImpl.componentType b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/CalculatorImpl.componentType
new file mode 100644
index 0000000000..299eb8c197
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/CalculatorImpl.componentType
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="ASCII"?>
+<!--
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+-->
+<componentType xmlns="http://www.osoa.org/xmlns/sca/1.0">
+
+  <service name="CalculatorService">
+        <interface.java interface="calculator.CalculatorService" />
+  </service>
+
+  <reference name="divideService">
+        <interface.java interface="calculator.DivideService" />
+  </reference>  
+
+</componentType>              
+       
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/JavaScriptReference.composite b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/JavaScriptReference.composite
new file mode 100644
index 0000000000..a313dd1e6d
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/JavaScriptReference.composite
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<!--

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.    

+-->

+<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"

+           xmlns:tuscany="http://tuscany.apache.org/xmlns/sca/1.0"

+           name="JavaScriptReference">

+

+    <component name="ClientComponent">

+        <implementation.java class="org.apache.tuscany.sca.implementation.script.itests.helloworld.HelloWorldProxy"/>

+    </component>

+

+    <component name="ReferenceComponent">

+        <tuscany:implementation.script script="org/apache/tuscany/sca/implementation/script/itests/references/reference.js"/>
+        <reference name="ref" target="TargetComponent" />
+    </component>

+

+    <component name="TargetComponent">

+        <implementation.java class="org.apache.tuscany.sca.implementation.script.itests.references.HelloWorldTarget"/>

+    </component>

+

+</composite>

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/Multiplicity.composite b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/Multiplicity.composite
new file mode 100644
index 0000000000..a221c23eec
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/Multiplicity.composite
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="ASCII"?>

+<!--

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ *

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.

+-->

+<composite xmlns="http://www.osoa.org/xmlns/sca/1.0" name="composite1" targetNamespace="http://temp"> 

+  <component name="data7"> 

+    <implementation.java class="temp.EchoImpl"/> 

+    <service name="Echo"> 

+      <interface.wsdl interface="http://echo.webservice#wsdl.interface(Echo)"/> 

+    </service> 

+    <reference multiplicity="0..n" name="reference" requires=""/> 

+  </component> 

+

+  <reference multiplicity="1..n" name="reference" promote="" requires=""/> 

+</composite>

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/NestedCalculator.composite b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/NestedCalculator.composite
new file mode 100644
index 0000000000..2719ee9162
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/NestedCalculator.composite
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<!--

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.    

+-->

+<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"

+	xmlns:calc="http://calc"
+	targetNamespace="http://calc"

+	name="Calculator">

+

+    <component name="CalculatorServiceComponent">

+		<implementation.composite xmlns:n="http://inner" name="n:InnerCalculator"/>

+    </component>

+

+</composite>

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/RMIBindingTest.composite b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/RMIBindingTest.composite
new file mode 100644
index 0000000000..d29fe85586
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/RMIBindingTest.composite
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ -->
+<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
+	       xmlns:tuscany="http://tuscany.apache.org/xmlns/sca/1.0"
+           name="HelloWorldRmiComposite">
+
+	<service name="HelloWorldRmiService" promote="HelloWorldServiceComponent">
+        <interface.java interface="helloworld.HelloWorldService"/>
+        <tuscany:binding.rmi host="localhost" port="8099" serviceName="HelloWorldRemoteService"   />
+    </service>
+      
+    <component name="HelloWorldServiceComponent">
+        <implementation.java class="helloworld.HelloWorldImpl"/>
+    </component>   
+  
+   <component name="HelloWorldRmiServiceComponent">
+        <implementation.java class="helloworld.HelloWorldRmiImpl"/>
+        <reference name="extService"></reference>
+    </component>        
+           
+  	<reference name="HelloWorldRmiReference" promote="HelloWorldRmiServiceComponent/extService">
+        <interface.java interface="helloworld.HelloWorldService"/>
+        <tuscany:binding.rmi host="localhost" port="8099" serviceName="HelloWorldRemoteService"   />
+    </reference>
+
+</composite>
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/TestAllCalculator.composite b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/TestAllCalculator.composite
new file mode 100644
index 0000000000..5091ff700b
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/TestAllCalculator.composite
@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<!--

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.    

+-->

+

+<composite autowire="false" constrainingType="tns:CalculatorComponent" local="true" name="TestAllCalculator" policySets="sns:SecureReliablePolicy"

+    requires="cns:confidentiality" targetNamespace="http://calc" xmlns:tns="http://calc"

+    xmlns="http://www.osoa.org/xmlns/sca/1.0" xmlns:xsd="http://www.w3.org/2001/XMLSchema"

+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

+    xsi:schemaLocation="http://www.osoa.org/xmlns/sca/1.0 http://www.osoa.org/xmlns/sca/1.0 "
+    xmlns:ext="http://extension"

+    xmlns:cns="http://test" xmlns:sns="http://test">

+

+    <include name="tns:TestAllDivide"/>

+    <ext:testExtension/>
+

+    <service name="CalculatorService" promote="CalculatorServiceComponent/CalculatorService" requires="cns:confidentiality"

+        policySets="sns:SecureReliablePolicy">
+        <ext:testExtension/>

+        <interface.java interface="calculator.CalculatorService" callbackInterface="calculator.CalculatorCallback" />

+        <operation name="add" policySets="sns:SecureReliablePolicy" requires="cns:confidentiality" />

+

+        <binding.ws name="CalculatorWS" policySets="sns:SecureReliablePolicy" port="" requires="cns:confidentiality" uri="http://calc/ws">

+            <operation name="add" policySets="sns:SecureReliablePolicy" requires="cns:confidentiality" />

+        </binding.ws>

+

+        <callback policySets="sns:SecureReliablePolicy" requires="cns:confidentiality">

+	        <ext:testExtension/>
+            <binding.ws name="CalculatorCallbackWS" policySets="" port="" requires="" uri="http://calc/callback/ws">

+                <operation name="addCallback" policySets="sns:SecureReliablePolicy" requires="cns:confidentiality" />

+            </binding.ws>

+        </callback>

+    </service>

+

+    <component name="CalculatorServiceComponent" autowire="false" constrainingType="tns:CalculatorComponent"

+        policySets="sns:SecureReliablePolicy" requires="cns:confidentiality">

+        <ext:testExtension/>
+        <service name="CalculatorService" policySets="sns:SecureReliablePolicy" requires="cns:confidentiality">

+            <interface.java interface="calculator.CalculatorService" callbackInterface="calculator.CalculatorCallback" />

+        </service>

+

+        <reference name="addService" target="AddServiceComponent/AddService" autowire="false" multiplicity="1..1"

+            policySets="sns:SecureReliablePolicy" requires="cns:confidentiality" wiredByImpl="false">

+            <ext:testExtension/>
+            <interface.java interface="calculator.AddService" callbackInterface="calculator.AddCallback" />

+        </reference>

+        <reference name="subtractService" target="SubtractServiceComponent" />

+        <reference name="multiplyService" />

+        <reference name="divideService" target="DivideServiceComponent" />

+

+        <property name="round" type="xsd:boolean" many="false">true</property>

+

+        <implementation.java class="calculator.CalculatorServiceImpl" policySets="" requires="" />

+    </component>

+

+    <component name="AddServiceComponent">

+        <service name="AddService">

+            <interface.java interface="calculator.AddService" />

+        </service>

+        <implementation.java class="calculator.AddServiceImpl" />

+    </component>

+

+    <component name="NestedCompositeComponent">
+        <service name="CalculatorService">
+            <interface.java interface="calculator.CalculatorService" />
+        </service>
+        <implementation.composite name="tns:Calculator" />
+    </component>
+
+    <component name="SubtractServiceComponent">

+        <implementation.java class="calculator.SubtractServiceImpl" />

+    </component>

+

+    <component name="MultiplyServiceComponent">

+        <implementation.java class="calculator.MultiplyServiceImpl" />

+    </component>

+

+    <component name="DivideServiceComponent">

+        <implementation.java class="calculator.DivideServiceImpl" />

+    </component>

+

+    <reference name="MultiplyService" promote="CalculatorServiceComponent/multiplyService" policySets="sns:SecureReliablePolicy"

+        requires="cns:confidentiality">

+        <interface.java interface="calculator.MultiplyService" callbackInterface="calculator.MultiplyCallback" />

+        <operation name="multiply" policySets="sns:SecureReliablePolicy" requires="cns:confidentiality" />

+

+        <binding.ws name="MultiplyWS" port="" policySets="sns:SecureReliablePolicy" requires="cns:confidentiality" uri="http://calc/ws">

+            <operation name="multiply" policySets="sns:SecureReliablePolicy" requires="cns:confidentiality" />

+        </binding.ws>

+

+        <callback policySets="sns:SecureReliablePolicy" requires="cns:confidentiality">

+            <binding.ws name="MultiplyCallbackWS" port="" uri="http://calc/callback/ws" policySets="sns:SecureReliablePolicy"

+                requires="cns:confidentiality">

+                <operation name="multiplyCallback" policySets="sns:SecureReliablePolicy" requires="cns:confidentiality" />

+            </binding.ws>

+        </callback>

+    </reference> 

+

+    <property name="prop1" xmlns:foo="http://foo" many="true" type="foo:MyComplexType">

+    	<ext:testExtension/>
+   	    <MyComplexPropertyValue1 xsi:type="foo:MyComplexType" attr="bar">

+            <foo:a>AValue</foo:a>

+            <bar:b xmlns:bar="http://bar">InterestingURI</bar:b>

+        </MyComplexPropertyValue1>

+        <MyComplexPropertyValue2 xsi:type="foo:MyComplexType" attr="zing">

+            <foo:a>BValue</foo:a>

+            <bar:b xmlns:bar="http://bar">BoringURI</bar:b>

+        </MyComplexPropertyValue2>

+    </property>

+    

+    <property name="prop2" xmlns:foo="http://foo" mustSupply="true" element="MyComplexPropertyValue1"/>

+

+</composite>

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/TestAllDivide.composite b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/TestAllDivide.composite
new file mode 100644
index 0000000000..d59e69209d
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/TestAllDivide.composite
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+-->
+<composite autowire="false"
+	constrainingType="tns:Calculator"
+	local="true"
+	name="TestAllDivide"
+	policySets="" requires=""
+	targetNamespace="http://calc"
+	xmlns:tns="http://calc"
+	xmlns="http://www.osoa.org/xmlns/sca/1.0"
+	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.osoa.org/xmlns/sca/1.0 http://www.osoa.org/xmlns/sca/1.0 ">
+	
+  <include name="tns:CompleteDivide"/>
+  
+  <service name="DivideService" policySets="" promote="CalculatorDivideComponent/DivideService" requires="">
+    <interface.java interface="calculator.DivideService" callbackInterface="calculator.DivideCallback"/>
+    <operation name="divide" policySets="" requires=""/>
+
+    <binding.ws name="CalculatorWS" policySets="" port="" requires="" uri="http://calc/ws">
+      <operation name="divide" policySets="" requires=""/>
+    </binding.ws>
+
+    <callback policySets="" requires="">
+      <binding.ws name="CalculatorCallbackWS" policySets="" port="" requires="" uri="http://calc/callback/ws">
+        <operation name="divideCallback" policySets="" requires=""/>
+      </binding.ws>
+    </callback>
+  </service>
+  
+   <component name="CalculatorDivideComponent" autowire="false" constrainingType="tns:CalculatorServiceComponent" policySets="" requires="">
+   		<service name="DivideService" policySets="" requires="">
+   			<interface.java interface="calculator.DivideService" callbackInterface="calculator.DivideCallback"/>
+   		</service>
+		<implementation.java class="calculator.DivideImpl" policySets="" requires=""/>
+   </component>
+
+</composite>
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/TestAllPolicyCalculator.composite b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/TestAllPolicyCalculator.composite
new file mode 100644
index 0000000000..7bc7ccdb83
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/TestAllPolicyCalculator.composite
@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<!--

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.    

+-->

+

+<composite autowire="false" constrainingType="tns:CalculatorComponent" local="true" name="TestAllCalculator" 

+    requires="cns:tuscanyIntent_1" targetNamespace="http://calc" xmlns:tns="http://calc"

+    xmlns="http://www.osoa.org/xmlns/sca/1.0" xmlns:xsd="http://www.w3.org/2001/XMLSchema"

+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

+    xsi:schemaLocation="http://www.osoa.org/xmlns/sca/1.0 http://www.osoa.org/xmlns/sca/1.0 "
+    xmlns:ext="http://extension"

+    xmlns:cns="http://test" xmlns:sns="http://test">

+

+    <include name="tns:TestAllDivide"/>

+    <ext:testExtension/>
+

+    <service name="CalculatorService" promote="CalculatorServiceComponent/CalculatorService" requires="cns:tuscanyIntent_2 cns:tuscanyIntent_1">
+        <ext:testExtension/>

+        <interface.java interface="calculator.CalculatorService" callbackInterface="calculator.CalculatorCallback" />

+        <operation name="add" requires="cns:tuscanyIntent_6"/>

+

+        <binding.ws name="CalculatorWS" port="" requires="cns:tuscanyIntent_3" uri="http://calc/ws">

+        </binding.ws>

+

+        <callback requires="cns:tuscanyIntent_4">

+	        <ext:testExtension/>
+            <binding.ws name="CalculatorCallbackWS" policySets="" port="" requires="cns:tuscanyIntent_5" uri="http://calc/callback/ws">

+            </binding.ws>

+        </callback>

+    </service>

+

+    <component name="CalculatorServiceComponent" autowire="false" constrainingType="tns:CalculatorComponent"

+        requires="cns:tuscanyIntent_2 cns:tuscanyIntent_3">

+        <ext:testExtension/>
+        <service name="CalculatorService" requires="cns:tuscanyIntent_3">

+            <interface.java interface="calculator.CalculatorService" callbackInterface="calculator.CalculatorCallback" />

+            <operation name="add" requires="cns:tuscanyIntent_6 cns:tuscanyIntent_7"/>

+            <binding.ws name="CalculatorCallbackWS" policySets="" port="" requires="cns:tuscanyIntent_4" uri="http://calc/callback/ws">

+            </binding.ws>

+            <callback>

+           	</callback>

+        </service>

+

+        <reference name="addService" target="AddServiceComponent/AddService" autowire="false" multiplicity="1..1"

+            requires="cns:tuscanyIntent_3 cns:tuscanyIntent_2.qualified" wiredByImpl="false">

+            <ext:testExtension/>
+            <interface.java interface="calculator.AddService" callbackInterface="calculator.AddCallback" />

+            <operation name="add" requires="cns:tuscanyIntent_8 cns:tuscanyIntent_9"/>

+            <binding.ws name="addServiceWSRef" policySets="" port="" requires="cns:tuscanyIntent_4" uri="http://calc/callback/ws">

+            </binding.ws>

+        </reference>

+        <reference name="subtractService" target="SubtractServiceComponent" />

+        <reference name="multiplyService" />

+        <reference name="divideService" target="DivideServiceComponent" />

+

+        <property name="round" type="xsd:boolean" many="false">true</property>

+

+        <implementation.java class="calculator.CalculatorServiceImpl" policySets="" requires="cns:tuscanyIntent_4" />

+    </component>

+

+    <component name="AddServiceComponent">

+        <service name="AddService">

+            <interface.java interface="calculator.AddService" />

+        </service>

+        <implementation.java class="calculator.AddServiceImpl" />

+    </component>

+

+    <component name="NestedCompositeComponent">
+        <service name="CalculatorService">
+            <interface.java interface="calculator.CalculatorService" />
+        </service>
+        <implementation.composite name="tns:Calculator" />
+    </component>
+
+    <component name="SubtractServiceComponent">

+        <implementation.java class="calculator.SubtractServiceImpl" />

+    </component>

+

+    <component name="MultiplyServiceComponent">

+        <implementation.java class="calculator.MultiplyServiceImpl" />

+    </component>

+

+    <component name="DivideServiceComponent">

+        <implementation.java class="calculator.DivideServiceImpl" />

+    </component>

+

+    <reference name="MultiplyService" promote="CalculatorServiceComponent/multiplyService" 

+        requires="cns:tuscanyIntent_2">

+        <interface.java interface="calculator.MultiplyService" callbackInterface="calculator.MultiplyCallback" />

+        <operation name="multiply" requires="cns:tuscanyIntent_6"/>

+

+        <binding.ws name="MultiplyWS" port="" requires="cns:tuscanyIntent_3" uri="http://calc/ws">

+        </binding.ws>

+

+        <callback policySets="sns:SecureReliablePolicy" requires="cns:tuscanyIntent_3">

+            <binding.ws name="MultiplyCallbackWS" port="" uri="http://calc/callback/ws" 

+                requires="cns:tuscanyIntent_4">

+            </binding.ws>

+        </callback>

+    </reference>

+

+    <property name="prop1" xmlns:foo="http://foo">

+    	<ext:testExtension/>
+   	    <MyComplexPropertyValue1 xsi:type="foo:MyComplexType" attr="bar">

+            <foo:a>AValue</foo:a>

+            <bar:b xmlns:bar="http://bar">InterestingURI</bar:b>

+        </MyComplexPropertyValue1>

+        <MyComplexPropertyValue2 xsi:type="foo:MyComplexType" attr="zing">

+            <foo:a>BValue</foo:a>

+            <bar:b xmlns:bar="http://bar">BoringURI</bar:b>

+        </MyComplexPropertyValue2>

+    </property>

+

+</composite>

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/another_test_definitions.xml b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/another_test_definitions.xml
new file mode 100644
index 0000000000..bcc8c54dc8
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/another_test_definitions.xml
@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="ASCII"?>

+<!--

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.    

+-->

+<sca:definitions xmlns="http://test"

+ 			targetNamespace="http://test"

+ 			xmlns:sca="http://www.osoa.org/xmlns/sca/1.0">

+

+<!-- simple intent -->

+ <sca:intent name="tuscanyIntent_1" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Sample Intent

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="tuscanyIntent_2" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Sample Intent

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="tuscanyIntent_3" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Sample Intent

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="tuscanyIntent_4" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Sample Intent

+ 			 </sca:description>

+ </sca:intent>

+ 

+<sca:intent name="tuscanyIntent_5" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Sample Intent

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="tuscanyIntent_6" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Sample Intent

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="tuscanyIntent_7" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Sample Intent

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="tuscanyIntent_8" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Sample Intent

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="tuscanyIntent_9" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Sample Intent

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="tuscanyIntent_10" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Sample Intent

+ 			 </sca:description>

+ </sca:intent>

+  <!-- qualified intents -->

+ <sca:intent name="tuscanyIntent_1.qualified" />

+ <sca:intent name="tuscanyIntent_2.qualified" />

+</sca:definitions>
\ No newline at end of file
diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/local.composite b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/local.composite
new file mode 100644
index 0000000000..3bda9ac31c
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/local.composite
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<!--

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.    

+-->

+<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"

+	xmlns:calc="http://localcalc"

+	xmlns:test="http://testlocal"

+	targetNamespace="http://localcalc"

+	name="LocalCalculator"

+      local="true">

+

+</composite>

diff --git a/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/test_definitions.xml b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/test_definitions.xml
new file mode 100644
index 0000000000..b79cb6b7b7
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.5.1/modules/assembly-xml/src/test/resources/org/apache/tuscany/sca/assembly/xml/test_definitions.xml
@@ -0,0 +1,175 @@
+<?xml version="1.0" encoding="ASCII"?>

+<!--

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.    

+-->

+<sca:definitions xmlns="http://test"

+ 			targetNamespace="http://test"

+ 			xmlns:sca="http://www.osoa.org/xmlns/sca/1.0">

+

+ <!-- qualified intents -->

+ <sca:intent name="confidentiality.transport" />

+ <sca:intent name="confidentiality.message" />

+ <sca:intent name="confidentiality.message.whole" />

+ <sca:intent name="confidentiality.message.body" /> 

+ 

+ <!-- POLICY SETS -->

+  <sca:policySet name="SecureReliablePolicy"

+ 	provides="confidentiality.transport integrity"

+ 	appliesTo="//sca:binding.ws | //sca:binding.sca"

+ 	xmlns="http://test"

+ 	xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">

+ 		<wsp:PolicyAttachment>

+ 			<!-- policy expression and policy subject for

+				 "basic authentication" -->

+		</wsp:PolicyAttachment>

+     	<wsp:PolicyAttachment>

+		 	<!-- policy expression and policy subject for

+		 		"reliability" -->

+		</wsp:PolicyAttachment>

+ </sca:policySet>

+ 

+ <sca:policySet name="SecureMessagingPolicies"

+	 provides="confidentiality"

+	 appliesTo="//sca:binding.ws"

+	 xmlns="http://test"

+ 	 xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">

+     <sca:intentMap provides="confidentiality" default="transport">

+        <sca:qualifier name="transport">

+            <wsp:Policy>

+                <!-- policy expression and policy subject for "transport" alternative -->

+                </wsp:Policy>

+            <wsp:Policy>...</wsp:Policy>

+        </sca:qualifier>

+        <sca:qualifier name="message">

+            <wsp:Policy>

+                <!-- policy expression and policy subject for "message" alternative" -->

+            </wsp:Policy>

+        </sca:qualifier>

+    </sca:intentMap>

+</sca:policySet>

+

+<sca:policySet name="SecurityPolicy" provides="confidentiality"

+	xmlns="http://test"

+	xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" >

+    <sca:intentMap provides="confidentiality" default="message">

+        <sca:qualifier name="message">

+            <sca:intentMap provides="message" default="whole">

+                <sca:qualifier name="body">

+                	<wsp:Policy>

+                		<!-- policy attachment for body encryption --> 

+               		</wsp:Policy>

+           		</sca:qualifier>

+                <sca:qualifier name="whole">

+                	<wsp:Policy>

+                		<!-- policy attachment for whole message encryption --> 

+               		</wsp:Policy>

+             	</sca:qualifier>

+            </sca:intentMap>

+        </sca:qualifier>

+        <sca:qualifier name="transport">

+        	<wsp:Policy>

+        		<!-- policy attachment for transport encryption --> 

+       		</wsp:Policy>

+        </sca:qualifier>

+    </sca:intentMap>

+</sca:policySet>

+

+<sca:policySet name="BasicAuthMsgProtSecurity"

+     provides="authentication confidentiality"

+     appliesTo="//sca:binding.ws"

+ 		xmlns="http://test">

+    <sca:policySetReference name="AuthenticationPolicies"/>

+    <sca:policySetReference name="ConfidentialityPolicies"/>

+</sca:policySet>

+

+<sca:policySet name="AuthenticationPolicies"

+	provides="authentication"

+	appliesTo="//sca:binding.ws"

+	xmlns="http://test"

+	xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">

+    <wsp:PolicyAttachment>

+        <!-- policy expression and policy subject for "basic

+        authentication" -->

+    </wsp:PolicyAttachment>

+</sca:policySet>

+

+<sca:policySet name="ConfidentialityPolicies"

+ provides="confidentiality"

+ bindings="binding.ws"

+ xmlns="http://test"

+    xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy">

+    <sca:intentMap provides="confidentiality"  default="transport">

+        <sca:qualifier name="transport">

+            <wsp:Policy>

+                <!-- policy expression and policy subject for "transport"

+                alternative -->

+            </wsp:Policy>

+            <wsp:Policy>...</wsp:Policy>

+        </sca:qualifier>

+        <sca:qualifier name="message">

+            <wsp:Policy>

+                <!-- policy expression and policy subject for "message"

+                alternative" -->...

+            </wsp:Policy>

+        </sca:qualifier>

+    </sca:intentMap>

+</sca:policySet>

+

+<!-- profile intent -->

+ <sca:intent name="reliableMessageProtection" 

+ 			 constrains="sca:binding"

+ 			 requires="messageProtection">

+ 			 <sca:description>

+ 			 	Protect messages from unauthorized reading or modification

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="messageProtection" 

+ 			 constrains="sca:binding"

+ 			 requires="confidentiality integrity">

+ 			 <sca:description>

+ 			 	Protect messages from unauthorized reading or modification

+ 			 </sca:description>

+ </sca:intent>

+

+<!-- simple intent -->

+ <sca:intent name="confidentiality" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Communitcation thro this binding must prevent

+ 			 unauthorized users from reading the messages.

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="integrity" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Communitcation thro this binding must prevent

+ 			 unauthorized modification of the messages.

+ 			 </sca:description>

+ </sca:intent>

+ 

+ <sca:intent name="authentication" 

+ 			 constrains="sca:binding">

+ 			 <sca:description>

+ 			 Communitcation thro this binding required

+ 			 Authentication.

+ 			 </sca:description>

+ </sca:intent>

+ 

+</sca:definitions>
\ No newline at end of file