8 files changed, 915 insertions, 0 deletions
diff --git a/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/HelloWorldClientImpl.java b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/HelloWorldClientImpl.java
new file mode 100644
index 0000000000..fb80362457
--- /dev/null
+++ b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/HelloWorldClientImpl.java
@@ -0,0 +1,43 @@
+/*
+ * 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.binding.jms;
+
+import org.osoa.sca.annotations.Reference;
+import org.osoa.sca.annotations.Service;
+
+/**
+ * This class implements the HelloWorld service.
+ *
+ * @version $Rev$ $Date$
+ */
+@Service(HelloWorldService.class)
+public class HelloWorldClientImpl implements HelloWorldService {
+
+    private HelloWorldService serviceA;
+
+    @Reference
+    public void setServiceA(HelloWorldService service) {
+        this.serviceA = service;
+    }
+
+    public String sayHello(String name) {
+        return serviceA.sayHello(name);
+    }
+
+}
diff --git a/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/HelloWorldService.java b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/HelloWorldService.java
new file mode 100644
index 0000000000..515da3144a
--- /dev/null
+++ b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/HelloWorldService.java
@@ -0,0 +1,31 @@
+/*
+ * 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.binding.jms;
+
+import org.osoa.sca.annotations.Remotable;
+
+/**
+ * Interface for the HelloWorld Service.
+ *
+ * @version $Rev$ $Date$
+ */
+@Remotable
+public interface HelloWorldService {
+    String sayHello(String name);
+}
diff --git a/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/HelloWorldServiceImpl.java b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/HelloWorldServiceImpl.java
new file mode 100644
index 0000000000..a8808c1bd1
--- /dev/null
+++ b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/HelloWorldServiceImpl.java
@@ -0,0 +1,32 @@
+/*
+ * 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.binding.jms;
+
+/**
+ * Implementation of the HelloWorldService.
+ *
+ * @version $Rev$ $Date$
+ */
+public class HelloWorldServiceImpl implements HelloWorldService {
+
+    public String sayHello(String name) {
+        return "jmsHello " + name;
+    }
+
+}
diff --git a/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/OperationSelectionTestCaseFIXME.java b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/OperationSelectionTestCaseFIXME.java
new file mode 100644
index 0000000000..b27795ab09
--- /dev/null
+++ b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/OperationSelectionTestCaseFIXME.java
@@ -0,0 +1,238 @@
+/*
+ * 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.binding.jms;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.jms.TextMessage;
+
+import org.apache.tuscany.sca.binding.jms.impl.JMSBinding;
+import org.apache.tuscany.sca.binding.jms.provider.JMSBindingListener;
+import org.apache.tuscany.sca.binding.jms.provider.JMSResourceFactory;
+import org.apache.tuscany.sca.interfacedef.Interface;
+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.runtime.RuntimeComponentService;
+import org.apache.tuscany.sca.runtime.RuntimeWire;
+import org.easymock.EasyMock;
+import org.junit.Test;
+
+/**
+ * This unit test is used to ensure that a JMS Message delivered to a Component will select the correct operation based
+ * on the details in section 1.5 of the JMS Binding specification.
+ *
+ * @version $Rev$ $Date$
+ */
+public class OperationSelectionTestCaseFIXME {
+    /**
+     * This test attempts to invoke a Service with a Single method where scaOperationName is not specified in the JMS
+     * Message
+     * <p>
+     * Expected behaviour is that the single method will be invoked as scaOperationName is ignored
+     * 
+     * @throws Exception Failed
+     */
+    @Test
+    public void testServiceWithOnlyOneOperationScaOperationNameNotSpecified() throws Exception {
+        // Create the operation we should match
+        final Operation expectedOperation = newOperation("myOperation");
+
+        // Create the list of operations for the Service
+        final List<Operation> operations = new ArrayList<Operation>();
+        operations.add(expectedOperation);
+
+        // The name of the Operation in the JMS Message - not specified
+        final String scaOperationName = null;
+
+        // Do the test
+        doTestJMSBinding(expectedOperation, operations, scaOperationName);
+    }
+
+    /**
+     * This test attempts to invoke a Service with a Single method where scaOperationName in the JMS Message matches the
+     * method name on the Service
+     * <p>
+     * Expected behaviour is that the single method will be invoked as scaOperationName is ignored
+     * 
+     * @throws Exception Failed
+     */
+    @Test
+    public void testServiceWithOnlyOneOperationScaOperationNameMatches() throws Exception {
+        // Create the operation we should match
+        final Operation expectedOperation = newOperation("myOperation");
+
+        // Create the list of operations for the Service
+        final List<Operation> operations = new ArrayList<Operation>();
+        operations.add(expectedOperation);
+
+        // The name of the Operation in the JMS Message - matches operation name
+        final String scaOperationName = expectedOperation.getName();
+
+        // Do the test
+        doTestJMSBinding(expectedOperation, operations, scaOperationName);
+    }
+
+    /**
+     * This test attempts to invoke a Service with a Single method where scaOperationName in the JMS Message is
+     * different the method name on the Service
+     * <p>
+     * Expected behaviour is that the single method will be invoked as scaOperationName is ignored
+     * 
+     * @throws Exception Failed
+     */
+    @Test
+    public void testServiceWithOnlyOneOperationScaOperationNameDifferent() throws Exception {
+        // Create the operation we should match
+        final Operation expectedOperation = newOperation("myOperation");
+
+        // Create the list of operations for the Service
+        final List<Operation> operations = new ArrayList<Operation>();
+        operations.add(expectedOperation);
+
+        // The name of the Operation in the JMS Message - different to operation name
+        final String scaOperationName = "Does Not Match Opeation Name";
+
+        // Do the test
+        doTestJMSBinding(expectedOperation, operations, scaOperationName);
+    }
+
+    /**
+     * This test attempts to invoke a Service with a multiple operations where scaOperationName specified in the JMS
+     * Message matches an operation name
+     * <p>
+     * Expected behaviour is that the named method will be invoked.
+     * 
+     * @throws Exception Failed
+     */
+    @Test
+    public void testServiceWithMultipleOperationsScaOperationNameSpecified() throws Exception {
+        // Create the list of operations for the Service
+        final List<Operation> operations = new ArrayList<Operation>();
+        for (int i = 0; i < 5; i++) {
+            operations.add(newOperation("operation" + i));
+        }
+
+        // Now try and invoke each operation
+        for (Operation expectedOperation : operations) {
+            // The name of the Operation in the JMS Message
+            final String scaOperationName = expectedOperation.getName();
+
+            // Do the test
+            doTestJMSBinding(expectedOperation, operations, scaOperationName);
+        }
+    }
+
+    /**
+     * This test attempts to invoke a Service with a multiple operations where scaOperationName specified in the JMS
+     * Message is not set so we invoke the onMessage() method
+     * <p>
+     * Expected behaviour is that the onMessage() method should be used instead
+     * 
+     * @throws Exception Failed
+     */
+    @Test
+    public void testServiceWithMultipleOperationsScaOperationNotSpecified() throws Exception {
+        // Create the list of operations for the Service
+        final List<Operation> operations = new ArrayList<Operation>();
+        for (int i = 0; i < 5; i++) {
+            operations.add(newOperation("operation" + i));
+        }
+
+        // Add the onMessage operation to the Service Contract
+        final Operation onMessageOperation = newOperation("onMessage");
+        operations.add(onMessageOperation);
+
+        // The name of the Operation in the JMS Message is not set so it will attempt
+        // to invoke the onMessage() method
+        final String scaOperationName = null;
+
+        // Do the test
+        doTestJMSBinding(onMessageOperation, operations, scaOperationName);
+    }
+
+    /**
+     * This is the test method that will attempt to unit test invoking a Service with the specified operations using a
+     * JMS Message with the specified scaOperationName to ensure that it invokes the expectedOperation
+     * 
+     * @param expectedOperation The Operation we are expecting to be invoked over JMS
+     * @param operations The list of Operations supported by the Service
+     * @param scaOperationName The value to set scaOperationName in the JMS Message
+     * @throws Exception Failed
+     */
+    private void doTestJMSBinding(Operation expectedOperation, List<Operation> operations, String scaOperationName)
+        throws Exception {
+        // Create the test JMS Binding
+        final JMSBinding jmsBinding = new JMSBinding();
+        JMSResourceFactory jmsResourceFactory = null;
+
+        // Extra information for the method we are invoking
+        final String operationParams = "Hello";
+        final Object operationReturnValue = "Operation Success";
+
+        // Mock up the Service. Basically, it is going to call:
+        // List<Operation> opList = service.getInterfaceContract().getInterface().getOperations();
+        final InterfaceContract ifaceContract = EasyMock.createStrictMock(InterfaceContract.class);
+        final RuntimeComponentService service = EasyMock.createStrictMock(RuntimeComponentService.class);
+        final Interface iface = EasyMock.createStrictMock(Interface.class);
+        EasyMock.expect(iface.getOperations()).andReturn(operations);
+        EasyMock.expect(ifaceContract.getInterface()).andReturn(iface);
+        EasyMock.expect(service.getInterfaceContract()).andReturn(ifaceContract);
+
+        // Mock up getting and invoking the RuntimeWire. It is going to call:
+        // service.getRuntimeWire(jmsBinding).invoke(operation, (Object[])requestPayload);
+        final RuntimeWire runtimeWire = EasyMock.createStrictMock(RuntimeWire.class);
+        EasyMock.expect(service.getRuntimeWire(jmsBinding)).andReturn(runtimeWire);
+        EasyMock.expect(runtimeWire.invoke(expectedOperation, new Object[] {operationParams}))
+            .andReturn(operationReturnValue);
+
+        // Create the JMS Binding Listener
+        final JMSBindingListener bindingListener = new JMSBindingListener(jmsBinding, jmsResourceFactory, service);
+
+        // Simulate a message
+        final TextMessage requestJMSMsg = EasyMock.createStrictMock(TextMessage.class);
+        EasyMock.expect(requestJMSMsg.getStringProperty("scaOperationName")).andReturn(scaOperationName);
+        EasyMock.expect(requestJMSMsg.getText()).andReturn(operationParams);
+        EasyMock.expect(requestJMSMsg.getJMSReplyTo()).andReturn(null);
+
+        // Lets put all the mocks into replay mode
+        // EasyMock.replay(iface);
+        EasyMock.replay(ifaceContract);
+        EasyMock.replay(service);
+        EasyMock.replay(requestJMSMsg);
+        EasyMock.replay(runtimeWire);
+
+        // Do the test
+        bindingListener.onMessage(requestJMSMsg);
+
+        // Verify our Mock objects
+        // EasyMock.verify(iface);
+        // EasyMock.verify(ifaceContract);
+        // EasyMock.verify(service);
+        // EasyMock.verify(requestJMSMsg);
+        // EasyMock.verify(runtimeWire);
+    }
+
+    private static Operation newOperation(String name) {
+        Operation operation = new OperationImpl();
+        operation.setName(name);
+        return operation;
+    }
+}
diff --git a/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/provider/JMSBindingReferenceQueueCreateModeTestCaseFIXME.java b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/provider/JMSBindingReferenceQueueCreateModeTestCaseFIXME.java
new file mode 100644
index 0000000000..96f0497303
--- /dev/null
+++ b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/provider/JMSBindingReferenceQueueCreateModeTestCaseFIXME.java
@@ -0,0 +1,326 @@
+/*
+ * 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.binding.jms.provider;
+
+import junit.framework.Assert;
+
+import org.apache.tuscany.sca.binding.jms.impl.JMSBinding;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBindingException;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.impl.OperationImpl;
+import org.junit.Test;
+
+/**
+ * This unit test tests various combinations of the JMS Binding create modes for both request and response queues.
+ * <p>
+ * The SCA JMS Binding specification lists 3 create modes:
+ * <ul>
+ * <li>always - the JMS queue is always created. It is an error if the queue already exists
+ * <li>ifnotexist - the JMS queue is created if it does not exist. It is not an error if the queue already exists
+ * <li>never - the JMS queue is never created. It is an error if the queue does not exist
+ * </ul>
+ * See the SCA JMS Binding specification for more information.
+ *
+ * @version $Rev$ $Date$
+ */
+public class JMSBindingReferenceQueueCreateModeTestCaseFIXME {
+
+    /**
+     * Test creating a request queue in "never" mode where the queue does not exist. We are expecting an exception
+     */
+    @Test
+    public void testRequestCreateNeverQueueNotExist() {
+        String requestCreateMode = "never";
+        String responseCreateMode = "ifnotexist";
+        boolean preCreateQueue = false;
+        boolean expectingRequestException = true;
+        boolean expectingResponseException = false;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a request queue in "never" mode where the queue exists. We are expecting this to work
+     */
+    @Test
+    public void testRequestCreateNeverQueueExists() {
+        String requestCreateMode = "never";
+        String responseCreateMode = "ifnotexist";
+        boolean preCreateQueue = true;
+        boolean expectingRequestException = false;
+        boolean expectingResponseException = false;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a request queue in "ifnotexist" mode where the queue does not exist. We are expecting this to work
+     */
+    @Test
+    public void testRequestCreateIfNotExistQueueNotExist() {
+        String requestCreateMode = "ifnotexist";
+        String responseCreateMode = "ifnotexist";
+        boolean preCreateQueue = false;
+        boolean expectingRequestException = false;
+        boolean expectingResponseException = false;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a request queue in "ifnotexist" mode where the queue exists. We are expecting this to work
+     */
+    @Test
+    public void testRequestCreateIfNotExistQueueExist() {
+        String requestCreateMode = "ifnotexist";
+        String responseCreateMode = "ifnotexist";
+        boolean preCreateQueue = true;
+        boolean expectingRequestException = false;
+        boolean expectingResponseException = false;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a request queue in "always" mode where the queue does not exist. We are expecting this to work
+     */
+    @Test
+    public void testRequestCreateAlwaysQueueNotExist() {
+        String requestCreateMode = "always";
+        String responseCreateMode = "ifnotexist";
+        boolean preCreateQueue = false;
+        boolean expectingRequestException = false;
+        boolean expectingResponseException = false;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a request queue in "always" mode where the queue exists. We are expecting an exception
+     */
+    @Test
+    public void testRequestCreateAlwaysQueueExists() {
+        String requestCreateMode = "always";
+        String responseCreateMode = "ifnotexist";
+        boolean preCreateQueue = true;
+        boolean expectingRequestException = true;
+        boolean expectingResponseException = false;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a response queue in "never" mode where the queue does not exist. We are expecting an exception
+     */
+    @Test
+    public void testResponseCreateNeverQueueNotExist() {
+        String requestCreateMode = "ifnotexist";
+        String responseCreateMode = "never";
+        boolean preCreateQueue = false;
+        boolean expectingRequestException = false;
+        boolean expectingResponseException = true;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a response queue in "never" mode where the queue exists. We are expecting this to work
+     */
+    @Test
+    public void testResponseCreateNeverQueueExists() {
+        String requestCreateMode = "ifnotexist";
+        String responseCreateMode = "never";
+        boolean preCreateQueue = true;
+        boolean expectingRequestException = false;
+        boolean expectingResponseException = false;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a response queue in "ifnotexist" mode where the queue does not exist. We are expecting this to work
+     */
+    @Test
+    public void testResponseCreateIfNotExistQueueNotExist() {
+        String requestCreateMode = "ifnotexist";
+        String responseCreateMode = "ifnotexist";
+        boolean preCreateQueue = false;
+        boolean expectingRequestException = false;
+        boolean expectingResponseException = false;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a response queue in "ifnotexist" mode where the queue not exists. We are expecting this to work
+     */
+    @Test
+    public void testResponseCreateIfNotExistQueueExist() {
+        String requestCreateMode = "ifnotexist";
+        String responseCreateMode = "ifnotexist";
+        boolean preCreateQueue = true;
+        boolean expectingRequestException = false;
+        boolean expectingResponseException = false;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a response queue in "always" mode where the queue does not exist. We are expecting this to work
+     */
+    @Test
+    public void testResponseCreateAlwaysQueueNotExist() {
+        String requestCreateMode = "ifnotexist";
+        String responseCreateMode = "always";
+        boolean preCreateQueue = false;
+        boolean expectingRequestException = false;
+        boolean expectingResponseException = false;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * Test creating a response queue in "always" mode where the queue exists. We are expecting an exception
+     */
+    @Test
+    public void testResponseCreateAlwaysQueueExists() {
+        String requestCreateMode = "ifnotexist";
+        String responseCreateMode = "always";
+        boolean preCreateQueue = true;
+        boolean expectingRequestException = false;
+        boolean expectingResponseException = true;
+
+        doTestCase(requestCreateMode,
+                   responseCreateMode,
+                   preCreateQueue,
+                   expectingRequestException,
+                   expectingResponseException);
+    }
+
+    /**
+     * This is the main test method for the various test scenarios for the JMS Binding.
+     * 
+     * @param requestCreateMode The required create mode for the request destination queue
+     * @param responseCreateMode The required create mode for the response destination queue
+     * @param preCreateQueue Whether the queue should be pre-created.
+     * @param expectingRequestException true if we are expecting an exception because the request queue configuration is
+     *            invalid; false otherwise
+     * @param expectingResponseException true if we are expecting an exception because the request queue configuration
+     *            is invalid; false otherwise
+     */
+    private void doTestCase(String requestCreateMode,
+                            String responseCreateMode,
+                            boolean preCreateQueue,
+                            boolean expectingRequestException,
+                            boolean expectingResponseException) {
+        String requestDestinationName = "SomeRequestDestination";
+        String responseDestinationName = "SomeResponseDestination";
+        String jmsBindingName = "MyJMSBinding";
+
+        // Create a JMS Binding with the required test parameters
+        JMSBinding jmsBinding = new JMSBinding();
+        jmsBinding.setDestinationCreate(requestCreateMode);
+        jmsBinding.setResponseDestinationCreate(responseCreateMode);
+        if (preCreateQueue) {
+//            jmsBinding.setJmsResourceFactoryName(new JMSResourceFactory(null, null, null));
+        } else {
+//            jmsBinding.setJmsResourceFactoryName(MockJMSResourceFactoryQueueNotExist.class.getName());
+        }
+        jmsBinding.setDestinationName(requestDestinationName);
+        jmsBinding.setResponseDestinationName(responseDestinationName);
+        jmsBinding.setName(jmsBindingName);
+
+        // Create the operation
+        Operation operation = new OperationImpl();
+        operation.setName("OperationName");
+
+        // Try and create the JMS Binding Invoker for the JMS Binding
+        try {
+            new JMSBindingInvoker(jmsBinding, operation, null);
+
+            // Check whether we were expecting an exception
+            if (expectingRequestException || expectingResponseException) {
+                // We were expecting an exception
+                Assert.fail("This binding should have failed as it is invalid");
+            }
+        } catch (JMSBindingException ex) {
+            // Were we expecting an exception
+            if (!expectingRequestException && !expectingResponseException) {
+                // No we were not expecting an exception
+                Assert.fail("Unexpected exception of " + ex);
+            }
+
+            // Validate that the expected exception has the text we expect
+            if (expectingRequestException) {
+                Assert.assertTrue(ex.getMessage().indexOf("JMS Destination") != -1);
+                Assert.assertTrue(ex.getMessage().indexOf(requestCreateMode) != -1);
+                Assert.assertTrue(ex.getMessage().indexOf(requestDestinationName) != -1);
+            } else if (expectingResponseException) {
+                Assert.assertTrue(ex.getMessage().indexOf("JMS Response Destination") != -1);
+                Assert.assertTrue(ex.getMessage().indexOf(responseCreateMode) != -1);
+                Assert.assertTrue(ex.getMessage().indexOf(responseDestinationName) != -1);
+            }
+            Assert.assertTrue(ex.getMessage().indexOf("registering binding " + jmsBindingName + " invoker") != -1);
+        }
+    }
+}
diff --git a/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/provider/JMSBindingServiceQueueCreateModeTestCaseFIXME.java b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/provider/JMSBindingServiceQueueCreateModeTestCaseFIXME.java
new file mode 100644
index 0000000000..c3c18fbfbe
--- /dev/null
+++ b/branches/sca-java-1.3.1/modules/binding-jms/src/test/java/org/apache/tuscany/sca/binding/jms/provider/JMSBindingServiceQueueCreateModeTestCaseFIXME.java
@@ -0,0 +1,172 @@
+/*
+ * 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.binding.jms.provider;
+
+import junit.framework.Assert;
+
+import org.apache.tuscany.sca.binding.jms.impl.JMSBinding;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBindingException;
+import org.apache.tuscany.sca.core.assembly.RuntimeComponentServiceImpl;
+import org.apache.tuscany.sca.runtime.RuntimeComponentService;
+import org.junit.Test;
+
+/**
+ * This method tests various combinations of the JMS Binding create modes.
+ * <p>
+ * The SCA JMS Binding specification lists 3 create modes:
+ * <ul>
+ * <li>always - the JMS queue is always created. It is an error if the queue already exists
+ * <li>ifnotexist - the JMS queue is created if it does not exist. It is not an error if the queue already exists
+ * <li>never - the JMS queue is never created. It is an error if the queue does not exist
+ * </ul>
+ * See the SCA JMS Binding specification for more information.
+ *
+ * @version $Rev$ $Date$
+ */
+public class JMSBindingServiceQueueCreateModeTestCaseFIXME {
+    /**
+     * Test creating a queue in "never" mode where the queue does not exist. We are expecting an exception
+     */
+    @Test
+    public void testCreateNeverQueueNotExist() {
+        String createMode = "never";
+        boolean preCreateQueue = false;
+        boolean expectingException = true;
+
+        doTestCase(createMode, preCreateQueue, expectingException);
+    }
+
+    /**
+     * Test creating a queue in "never" mode where the queue exists. We are expecting this to work
+     */
+    @Test
+    public void testCreateNeverQueueExist() {
+        String createMode = "never";
+        boolean preCreateQueue = true;
+        boolean expectingException = false;
+
+        doTestCase(createMode, preCreateQueue, expectingException);
+    }
+
+    /**
+     * Test creating a queue in "ifnotexist" mode where the queue does not exist. We are expecting this to work
+     */
+    @Test
+    public void testCreateIfNotExistQueueNotExist() {
+        String createMode = "ifnotexist";
+        boolean preCreateQueue = false;
+        boolean expectingException = false;
+
+        doTestCase(createMode, preCreateQueue, expectingException);
+    }
+
+    /**
+     * Test creating a queue in "ifnotexist" mode where the queue exists. We are expecting this to work
+     */
+    @Test
+    public void testCreateIfNotExistQueueExist() {
+        String createMode = "ifnotexist";
+        boolean preCreateQueue = true;
+        boolean expectingException = false;
+
+        doTestCase(createMode, preCreateQueue, expectingException);
+    }
+
+    /**
+     * Test creating a queue in "always" mode where the queue does not exist. We are expecting this to work
+     */
+    @Test
+    public void testCreateAlwaysQueueNotExist() {
+        String createMode = "always";
+        boolean preCreateQueue = false;
+        boolean expectingException = false;
+
+        doTestCase(createMode, preCreateQueue, expectingException);
+    }
+
+    /**
+     * Test creating a queue in "always" mode where the queue exists. We are expecting an exception
+     */
+    @Test
+    public void testCreateAlwaysQueueExist() {
+        String createMode = "always";
+        boolean preCreateQueue = true;
+        boolean expectingException = true;
+
+        doTestCase(createMode, preCreateQueue, expectingException);
+    }
+
+    /**
+     * This is the main test method for the various test scenarios for the JMS Binding.
+     * 
+     * @param createMode The required create mode for the destination queue
+     * @param preCreateQueue Whether the queue should be pre-created.
+     * @param expectingException true if test should throw an exception
+     */
+    private void doTestCase(String createMode, boolean preCreateQueue, boolean expectingException) {
+        String destinationName = "SomeDestination";
+        String jmsBindingName = "MyJMSBinding";
+        String serviceName = "MyServiceName";
+
+        // Create a JMS Binding with the required test parameters
+        JMSBinding jmsBinding = new JMSBinding();
+        jmsBinding.setDestinationCreate(createMode);
+//        if (preCreateQueue) {
+//            jmsBinding.setJmsResourceFactoryName(MockJMSResourceFactoryQueueExist.class.getName());
+//        } else {
+//            jmsBinding.setJmsResourceFactoryName(MockJMSResourceFactoryQueueNotExist.class.getName());
+//        }
+        jmsBinding.setDestinationName(destinationName);
+        jmsBinding.setName(jmsBindingName);
+
+        RuntimeComponentService service = new RuntimeComponentServiceImpl();
+        service.setName(serviceName);
+
+        // Try and create the JMS Binding Service for the JMS Binding
+        try {
+            JMSBindingServiceBindingProvider jmsService =
+                new JMSBindingServiceBindingProvider(null, service, jmsBinding, null);
+            jmsService.start();
+
+            // Check whether we were expecting an exception
+            if (expectingException) {
+                // We were expecting an exception
+                Assert.fail("This binding should have failed as it is invalid");
+            }
+        } catch (JMSBindingException ex) {
+            // Were we expecting an exception
+            if (!expectingException) {
+                ex.printStackTrace();
+                // No we were not expecting an exception
+                Assert.fail("Unexpected exception of " + ex);
+            }
+
+            // We should get a JMSBindingException
+            Assert.assertTrue(ex.getMessage().indexOf("Error starting JMSServiceBinding") != -1);
+
+            // Validate that the expected chained exception exception has the text we expect
+            Assert.assertNotNull(ex.getCause());
+            Assert.assertTrue(ex.getCause().getMessage().indexOf("JMS Destination") != -1);
+            Assert.assertTrue(ex.getCause().getMessage().indexOf(createMode) != -1);
+            Assert.assertTrue(ex.getCause().getMessage().indexOf(destinationName) != -1);
+            Assert
+                .assertTrue(ex.getCause().getMessage().indexOf("registering service " + serviceName + " listener") != -1);
+        }
+    }
+}
diff --git a/branches/sca-java-1.3.1/modules/binding-jms/src/test/resources/simple/client.composite b/branches/sca-java-1.3.1/modules/binding-jms/src/test/resources/simple/client.composite
new file mode 100644
index 0000000000..dcea428493
--- /dev/null
+++ b/branches/sca-java-1.3.1/modules/binding-jms/src/test/resources/simple/client.composite
@@ -0,0 +1,38 @@
+<?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"
+           name="RPCComposite">
+
+    <component name="HelloWorldClient">
+        <implementation.java class="org.apache.tuscany.sca.binding.jms.HelloWorldClientImpl"/>
+        <reference name="serviceA" />
+    </component>
+
+    <reference name="serviceA" promote="HelloWorldClient/serviceA">
+        <interface.java interface="org.apache.tuscany.sca.binding.jms.HelloWorldService" />
+        <binding.jms initialContextFactory="org.apache.activemq.jndi.ActiveMQInitialContextFactory" jndiURL="tcp://localhost:61616">
+            <destination name="DestQueueA"/>
+            <response>
+               <destination name="RespQueueA"/>
+            </response>
+        </binding.jms>  
+    </reference>
+
+</composite>
diff --git a/branches/sca-java-1.3.1/modules/binding-jms/src/test/resources/simple/service.composite b/branches/sca-java-1.3.1/modules/binding-jms/src/test/resources/simple/service.composite
new file mode 100644
index 0000000000..44b7b29610
--- /dev/null
+++ b/branches/sca-java-1.3.1/modules/binding-jms/src/test/resources/simple/service.composite
@@ -0,0 +1,35 @@
+<?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"
+           name="RPCComposite">
+
+    <component name="HelloWorldService">
+        <implementation.java class="org.apache.tuscany.sca.binding.jms.HelloWorldServiceImpl"/>
+        <service name="HelloWorldService">
+            <binding.jms initialContextFactory="org.apache.activemq.jndi.ActiveMQInitialContextFactory" jndiURL="tcp://localhost:61616">
+               <destination name="DestQueueA" create="always"/>
+               <response>
+                  <destination name="RespQueueA" create="always"/>
+               </response>
+            </binding.jms>  
+        </service> 
+    </component>       
+
+</composite>