1 files changed, 373 insertions, 0 deletions
diff --git a/sca-java-1.x/branches/sca-java-1.6.2/itest/contribution-classloader/contribution-test/src/test/java/org/apache/tuscany/sca/test/contribution/ContributionTestCase.java b/sca-java-1.x/branches/sca-java-1.6.2/itest/contribution-classloader/contribution-test/src/test/java/org/apache/tuscany/sca/test/contribution/ContributionTestCase.java
new file mode 100644
index 0000000000..692f16f6f6
--- /dev/null
+++ b/sca-java-1.x/branches/sca-java-1.6.2/itest/contribution-classloader/contribution-test/src/test/java/org/apache/tuscany/sca/test/contribution/ContributionTestCase.java
@@ -0,0 +1,373 @@
+/*
+ * 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.test.contribution;
+
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URLClassLoader;
+
+import org.apache.tuscany.sca.contribution.Contribution;
+import org.apache.tuscany.sca.contribution.resolver.ClassReference;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/*
+ * 
+ * Contribution ClassLoading integration tests
+ */
+
+public class ContributionTestCase {
+
+    private SupplyChain supplyChain;
+    
+    
+    @Before
+    public void setUp() throws Exception {
+        supplyChain = new SupplyChain();
+    }
+	
+
+	@After
+    public void tearDown() throws Exception {
+
+        supplyChain.tearDown();
+        
+	}
+
+   
+    /**
+     * Test static ClassLoading for classes that are visible from contribution
+     * 
+     * @throws Exception
+     */
+    public void staticClassLoadingTestForVisibleClasses() throws Exception {
+        
+        Contribution customerContribution = supplyChain.getContribution("Customer");
+        ClassReference customerClassRef = new ClassReference("supplychain.customer.Customer");
+        customerClassRef = customerContribution.getModelResolver().resolveModel(ClassReference.class, customerClassRef);
+        Class<?> customerClass = customerClassRef.getJavaClass();
+        
+        Class customerClassFromContribution = customerContribution.getClassLoader().loadClass("supplychain.customer.Customer");
+        Assert.assertEquals(customerClass, customerClassFromContribution);
+        
+        Object customer = supplyChain.getCustomer(customerClass);
+                
+        Method m = customerClass.getMethod("purchaseGoods");
+        m.invoke(customer);
+        
+
+        m = customerClass.getMethod("outstandingOrderCount");
+        
+        int retries = 10;
+        int outstandingCount = 1;
+        while (retries-- > 0) {
+        
+            outstandingCount = (int)(Integer)m.invoke(customer);
+            if (outstandingCount == 0)
+                break;
+            else
+                Thread.sleep(100);
+        }
+        Assert.assertEquals(0, outstandingCount);
+        
+        
+    }
+    
+
+    /**
+     * Test dynamic ClassLoading for classes that are visible from contribution
+     * 
+     * @throws Exception
+     */
+    public void dynamicClassLoadingTestForVisibleClasses() throws Exception {
+        
+        Contribution customerContribution = supplyChain.getContribution("Customer");
+        Contribution retailerContribution = supplyChain.getContribution("Retailer");
+        Contribution warehouseContribution = supplyChain.getContribution("Warehouse");
+        Contribution shipperContribution = supplyChain.getContribution("Shipper");
+        Contribution supplyChainContribution = supplyChain.getContribution("SupplyChain");
+        
+        ClassReference customerClassRef = new ClassReference("supplychain.customer.Customer");
+        customerClassRef = customerContribution.getModelResolver().resolveModel(ClassReference.class, customerClassRef);
+        Class customerClass = customerClassRef.getJavaClass();
+        
+        Class customerClassFromContribution = customerContribution.getClassLoader().loadClass("supplychain.customer.Customer");
+        Assert.assertEquals(customerClass, customerClassFromContribution);
+        
+        Object customer = supplyChain.getCustomer(customerClass);
+        Assert.assertTrue(customerClass.isInstance(customer));
+        
+        ClassReference retailerClassRef = new ClassReference("supplychain.retailer.Retailer");
+        retailerClassRef = retailerContribution.getModelResolver().resolveModel(ClassReference.class, retailerClassRef);
+        Class retailerClass = retailerClassRef.getJavaClass();
+        
+        Class retailerClassFromContribution = retailerContribution.getClassLoader().loadClass("supplychain.retailer.Retailer");
+        Assert.assertEquals(retailerClass, retailerClassFromContribution);
+        
+        Class retailerClassFromCustomer = customerContribution.getClassLoader().loadClass("supplychain.retailer.Retailer");
+        Assert.assertEquals(retailerClass, retailerClassFromCustomer);
+        
+        ClassReference warehouseClassRef = new ClassReference("supplychain.warehouse.Warehouse");
+        warehouseClassRef = warehouseContribution.getModelResolver().resolveModel(ClassReference.class, warehouseClassRef);
+        Class warehouseClass = warehouseClassRef.getJavaClass();
+        
+        Class warehouseClassFromContribution = warehouseContribution.getClassLoader().loadClass("supplychain.warehouse.Warehouse");
+        Assert.assertEquals(warehouseClass, warehouseClassFromContribution);
+        
+        Class warehouseClassFromRetailer = retailerContribution.getClassLoader().loadClass("supplychain.warehouse.Warehouse");
+        Assert.assertEquals(warehouseClass, warehouseClassFromRetailer);
+        
+        ClassReference shipperClassRef = new ClassReference("supplychain.shipper.Shipper");
+        shipperClassRef = shipperContribution.getModelResolver().resolveModel(ClassReference.class, shipperClassRef);
+        Class shipperClass = shipperClassRef.getJavaClass();
+        
+        Class shipperClassFromContribution = shipperContribution.getClassLoader().loadClass("supplychain.shipper.Shipper");
+        Assert.assertEquals(shipperClass, shipperClassFromContribution);
+        
+        Class shipperClassFromWarehouse = shipperContribution.getClassLoader().loadClass("supplychain.shipper.Shipper");
+        Assert.assertEquals(shipperClass, shipperClassFromWarehouse);
+        
+        Class customerClassFromShipper = shipperContribution.getClassLoader().loadClass("supplychain.customer.Customer");
+        Assert.assertEquals(customerClass, customerClassFromShipper);
+        
+        Class customerClassFromSupplyChain = supplyChainContribution.getClassLoader().loadClass("supplychain.customer.Customer");
+        Assert.assertEquals(customerClass, customerClassFromSupplyChain);
+        Class retailerClassFromSupplyChain = supplyChainContribution.getClassLoader().loadClass("supplychain.retailer.Retailer");
+        Assert.assertEquals(retailerClass, retailerClassFromSupplyChain);
+        Class warehouseClassFromSupplyChain = supplyChainContribution.getClassLoader().loadClass("supplychain.warehouse.Warehouse");
+        Assert.assertEquals(warehouseClass, warehouseClassFromSupplyChain);
+        Class shipperClassFromSupplyChain = supplyChainContribution.getClassLoader().loadClass("supplychain.shipper.Shipper");
+        Assert.assertEquals(shipperClass, shipperClassFromSupplyChain);
+        
+    }
+    
+    /**
+     * Test dynamic ClassLoading for classes that are visible from contribution
+     * 
+     * @throws Exception
+     */
+    public void dynamicClassLoadingTestForNonImportedClasses() throws Exception {
+        
+        Contribution customerContribution = supplyChain.getContribution("Customer");
+        Contribution shipperContribution = supplyChain.getContribution("Shipper");
+        
+        Class customerClass = customerContribution.getClassLoader().loadClass("supplychain.customer.Customer"); 
+        Class shipperClass = shipperContribution.getClassLoader().loadClass("supplychain.shipper.Shipper");
+        
+        try {
+            customerClass.getClassLoader().loadClass("supplychain.warehouse.Warehouse");
+            Assert.fail("Non-imported class loaded incorrectly");
+        } catch (ClassNotFoundException e) {
+        }
+        try {
+            customerClass.getClassLoader().loadClass("supplychain.shipper.JavaShipperComponentImpl");
+            Assert.fail("Non-imported class loaded incorrectly");
+        } catch (ClassNotFoundException e) {
+        }
+        
+        try {
+            Class.forName("supplychain.warehouse.Warehouse", true, customerClass.getClassLoader());
+            Assert.fail("Non-imported class loaded incorrectly");
+        } catch (ClassNotFoundException e) {
+        }
+        try {
+            Class.forName("supplychain.shipper.JavaShipperComponentImpl", true, customerClass.getClassLoader());
+            Assert.fail("Non-imported class loaded incorrectly");
+        } catch (ClassNotFoundException e) {
+        }
+        
+        try {
+            shipperClass.getClassLoader().loadClass("supplychain.warehouse.JavaWarehouseComponentImpl");
+            Assert.fail("Non-imported class loaded incorrectly");
+        } catch (ClassNotFoundException e) {
+        }
+        try {
+            shipperClass.getClassLoader().loadClass("supplychain.retailer.Retailer");
+            Assert.fail("Non-imported class loaded incorrectly");
+        } catch (ClassNotFoundException e) {
+        }
+        
+        try {
+            Class.forName("supplychain.warehouse.JavaWarehouseComponentImpl", true, shipperClass.getClassLoader());
+            Assert.fail("Non-imported class loaded incorrectly");
+        } catch (ClassNotFoundException e) {
+        }
+        try {
+            Class.forName("supplychain.retailer.Retailer", true, shipperClass.getClassLoader());
+            Assert.fail("Non-imported class loaded incorrectly");
+        } catch (ClassNotFoundException e) {
+        }
+        
+        
+    }
+    
+
+    /**
+     * This test ensures that classes from imported packages can be statically loaded 
+     * from other contributions even though the classes are not on CLASSPATH or on the 
+     * parent ClassLoader, or the thread context ClassLoader.
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testValidStaticClassLoading() throws Exception {
+               
+        supplyChain.setUp(this.getClass().getClassLoader());
+        
+        staticClassLoadingTestForVisibleClasses();
+    }
+    
+    /**
+     * This test ensures that all imported classes are loaded from the exporting contributions 
+     * rather than the parent classLoader. If any of the interface classes were incorrectly loaded 
+     * through the parent ClassLoader, LinkageError should result.
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testValidStaticClassLoadingWithContributionsInParentClassLoader() throws Exception {
+        
+        
+        URLClassLoader parentClassLoader = new URLClassLoader(
+                supplyChain.getContributionURLs(),
+                this.getClass().getClassLoader());
+
+        supplyChain.setUp(parentClassLoader);
+        
+        staticClassLoadingTestForVisibleClasses();
+    }
+    
+    
+    /**
+     * This test ensures that classes from imported packages can be dynamically loaded from
+     * other contributions even though the classes are not on CLASSPATH or on the 
+     * parent ClassLoader, or the thread context ClassLoader.
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testValidDynamicClassLoading() throws Exception {
+               
+        supplyChain.setUp(this.getClass().getClassLoader());
+        
+        dynamicClassLoadingTestForVisibleClasses();
+    }
+    
+    /**
+     * This test ensures that all imported classes are dynamically loaded from the exporting 
+     * contributions rather  than the parent classLoader. If any of the interface classes were 
+     * incorrectly loaded through the parent, NoClassDefFoundError or LinkageError should result.
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testValidDynamicClassLoadingWithContributionsInParentClassLoader() throws Exception {
+        
+        
+        URLClassLoader parentClassLoader = new URLClassLoader(
+                supplyChain.getContributionURLs(),
+                this.getClass().getClassLoader());
+
+        supplyChain.setUp(parentClassLoader);
+        
+        dynamicClassLoadingTestForVisibleClasses();
+    }
+    
+    @Test
+    public void testIllegalStaticClassLoading1() throws Exception {
+        // FIXME we have commented this code as we are not throwing exceptions anymore
+    	// need to deal with monitor logs to catch the errors.
+        
+    	/*try {
+            supplyChain.setUp(this.getClass().getClassLoader(), SupplyChain.SUPPLYCHAIN_ILLEGAL_1);
+        
+            Assert.fail("Composite containing unresolved references resolved incorrectly");
+        } catch (ContributionResolveException e) {
+        }*/
+    }
+    
+    @Test
+    public void testIllegalStaticClassLoading2() throws Exception {
+          
+        supplyChain.setUp(this.getClass().getClassLoader(), SupplyChain.SUPPLYCHAIN_ILLEGAL_2);
+        
+        Contribution customerContribution = supplyChain.getContribution("Customer");
+        ClassReference customerClassRef = new ClassReference("supplychain.customer.Customer");
+        customerClassRef = customerContribution.getModelResolver().resolveModel(ClassReference.class, customerClassRef);
+        Class<?> customerClass = customerClassRef.getJavaClass();
+        
+        Object customer = supplyChain.getCustomer(customerClass);
+                
+        try {
+            Method m = customerClass.getMethod("purchaseGoods");
+            m.invoke(customer);
+            
+            Assert.fail("Classloading exception not thrown as expected");
+        } catch (InvocationTargetException e) {
+            
+            Throwable cause = e.getCause();
+            Assert.assertTrue(cause instanceof NoClassDefFoundError);
+            Assert.assertTrue(cause.getMessage().indexOf("JavaWarehouseComponentImpl") > -1);        }
+        
+    }
+    
+    /**
+     * This test ensures that classes from imported packages can be dynamically loaded from
+     * other contributions even though the classes are not on CLASSPATH or on the 
+     * parent ClassLoader, or the thread context ClassLoader.
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testIllegalDynamicClassLoading() throws Exception {
+               
+        supplyChain.setUp(this.getClass().getClassLoader());
+        
+        dynamicClassLoadingTestForNonImportedClasses();
+    }
+    
+    
+    /**
+     * Self-contained contribution containing composites, componentType files and implementations
+     * should not require import/export statements for these files to find each other or for Tuscany
+     * to load these files.
+     * @throws Exception
+     */
+    @Test
+    public void testSelfContainedContribution() throws Exception {
+               
+        supplyChain.setUp(this.getClass().getClassLoader(), SupplyChain.SUPPLYCHAIN_SELFCONTAINED);
+        
+        staticClassLoadingTestForVisibleClasses();
+    }
+    
+    @Test
+    public void testContributionsWithSplitPackage() throws Exception {
+               
+        supplyChain.setUp(this.getClass().getClassLoader(), SupplyChain.SUPPLYCHAIN_SPLITPACKAGE);
+        
+        staticClassLoadingTestForVisibleClasses();
+        
+        dynamicClassLoadingTestForNonImportedClasses();
+    }
+}