| /** |
| * |
| * 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.sdo.test; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.math.BigDecimal; |
| import java.net.URL; |
| import java.util.Iterator; |
| import java.util.Vector; |
| |
| import junit.framework.TestCase; |
| |
| import org.apache.tuscany.sdo.api.SDOUtil; |
| |
| import commonj.sdo.DataObject; |
| import commonj.sdo.Property; |
| import commonj.sdo.Type; |
| import commonj.sdo.helper.CopyHelper; |
| import commonj.sdo.helper.DataFactory; |
| import commonj.sdo.helper.HelperContext; |
| import commonj.sdo.helper.TypeHelper; |
| |
| public class CrossScopeCopyTestCase extends TestCase |
| { |
| // Literals |
| private static final String TEST_NAMESPACE = "http://www.example.com/bank"; |
| private static final String BANK_MODEL = "/bank.xsd"; |
| private static final String BANK_TYPE = "bankType"; |
| private static final String BRANCH_TYPE = "branchType"; |
| private static final String SERVICE_TYPE = "serviceType"; |
| private static final String ACCOUNT_TYPE = "accountType"; |
| private static final String CUSTOMER_TYPE = "customerType"; |
| private static final String ADDRESS_TYPE = "addressType"; |
| private static final String DYNAMIC_TYPE = "dynamicType"; |
| |
| // SDO model objects |
| private HelperContext hca; |
| private HelperContext hcb; |
| private TypeHelper scopeA; |
| private TypeHelper scopeB; |
| |
| // SDO instance objects |
| private DataObject bankSDO; |
| private DataObject branchSDO1; |
| private DataObject branchSDO2; |
| private DataObject serviceSDO1; |
| private DataObject serviceSDO2; |
| private DataObject serviceSDO3; |
| private DataObject customerSDO1; |
| private DataObject customerSDO2; |
| private DataObject customerSDO3; |
| private DataObject customerSDO4; |
| |
| private int indent = 0; |
| |
| public void testCrossScopeCopy() throws IOException |
| { |
| CopyHelper copyHelperB = SDOUtil.createCrossScopeCopyHelper(hcb); |
| |
| // Perform Shallow Copy Test |
| DataObject copiedSDO = copyHelperB.copyShallow(bankSDO); |
| shallowCopyAssertions(bankSDO, copiedSDO); |
| |
| // Perform Deep Copy Test |
| copiedSDO = copyHelperB.copy(bankSDO); |
| deepCopyAssertions(bankSDO, copiedSDO); |
| |
| // Inter-Reference Copy |
| copiedSDO = copyHelperB.copy(customerSDO1); |
| DataObject prop = (DataObject)copiedSDO.get("HomeBranch"); |
| assertTrue(prop==null); |
| |
| // Perform invalid namespace test |
| DataObject sdo = hca.getDataFactory().create(TEST_NAMESPACE, DYNAMIC_TYPE ); |
| sdo.set("custNum", "099" ); |
| sdo.set("firstName", "John"); |
| sdo.set("lastName", "Doe"); |
| boolean failed = false; |
| try |
| { |
| // In this case, we are copying an object to a scope |
| // where the object's type has not been defined. That |
| // will generate a null pointer exception what we will |
| // catch. |
| copyHelperB.copy(sdo); |
| } |
| catch(java.lang.NullPointerException ex) |
| { |
| failed = true; |
| } |
| assertTrue(failed); |
| } |
| |
| protected void setUp() throws Exception |
| { |
| super.setUp(); |
| |
| // Create Two Scopes |
| hca = SDOUtil.createHelperContext(); |
| hcb = SDOUtil.createHelperContext(); |
| scopeA = hca.getTypeHelper(); |
| scopeB = hcb.getTypeHelper(); |
| |
| // Populate scopes with bank model now |
| URL url = getClass().getResource(BANK_MODEL); |
| InputStream inputStream = url.openStream(); |
| hca.getXSDHelper().define(inputStream, url.toString()); |
| inputStream.close(); |
| inputStream = url.openStream(); |
| hcb.getXSDHelper().define(inputStream, url.toString()); |
| inputStream.close(); |
| |
| // Now Populate scopeA with some dynamic models |
| populateScopeWithDynamicTypes(scopeA); |
| |
| // Construct Source Tree |
| constructSourceTree(hca.getDataFactory()); |
| } |
| |
| private void shallowCopyAssertions(DataObject sdo, DataObject copiedSdo) |
| { |
| assertEquals(sdo.getType().getName(), copiedSdo.getType().getName()); |
| assertEquals(sdo.getType().getURI(), copiedSdo.getType().getURI()); |
| assertNotSame(sdo.getType(), copiedSdo.getType()); |
| assertEquals(sdo.getInstanceProperties().size(), copiedSdo |
| .getInstanceProperties().size()); |
| |
| for(Iterator it = sdo.getInstanceProperties().iterator(), it2 = copiedSdo |
| .getInstanceProperties().iterator(); it.hasNext();) |
| { |
| Property p1 = (Property) it.next(), p2 = (Property) it2.next(); |
| assertEquals(p1.getName(), p2.getName()); |
| Object o1 = sdo.get(p1), o2 = copiedSdo.get(p2); |
| if(p1.getType().isDataType()) |
| { |
| assertEquals(o1, o2); |
| // TODO is there a way I can distinguish between mutable and |
| // immutable types |
| // so that I can do some "same object" tests |
| } |
| else |
| { |
| assertNotSame(p1, p2); |
| if(p2.isMany()) |
| { |
| assertEquals(copiedSdo.getList(p2).size(), 0); |
| } |
| else |
| { |
| assertNull(copiedSdo.get(p2)); |
| } |
| } |
| try |
| { |
| sdo.get(p2); |
| assertTrue(false); |
| } |
| catch(Exception e) |
| { |
| // expected route |
| } |
| try |
| { |
| copiedSdo.get(p1); |
| assertTrue(false); |
| } |
| catch(Exception e2) |
| { |
| // expected route |
| } |
| } |
| } |
| |
| private void deepCopyAssertions(DataObject sdo, DataObject copiedSdo) |
| { |
| //indent(); |
| |
| //System.out.println("checking objects of types: " |
| // + sdo.getType().getName() + ", " |
| // + copiedSdo.getType().getName()); |
| indent++; |
| |
| assertEquals(sdo.getType().getName(), copiedSdo.getType().getName()); |
| assertEquals(sdo.getType().getURI(), copiedSdo.getType().getURI()); |
| assertNotSame(sdo.getType(), copiedSdo.getType()); |
| assertEquals(sdo.getInstanceProperties().size(), copiedSdo |
| .getInstanceProperties().size()); |
| |
| for(Iterator it = sdo.getInstanceProperties().iterator(), it2 = copiedSdo |
| .getInstanceProperties().iterator(); it.hasNext();) |
| { |
| Property p1 = (Property) it.next(), p2 = (Property) it2.next(); |
| assertEquals(p1.getName(), p2.getName()); |
| Object o1 = sdo.get(p1), o2 = copiedSdo.get(p2); |
| if(p1.getType().isDataType()) |
| { |
| assertEquals(o1, o2); |
| // TODO is there a way I can distinguish between mutable and |
| // immutable types |
| // so that I can do some "same object" tests |
| } |
| else |
| { |
| assertNotSame(p1, p2); |
| if(p2.isMany()) |
| { |
| assertEquals(sdo.getList(p1).size(), copiedSdo.getList(p2) |
| .size()); |
| for(Iterator it3 = sdo.getList(p1).iterator(), it4 = copiedSdo |
| .getList(p2).iterator(); it3.hasNext();) |
| { |
| deepCopyAssertions((DataObject) it3.next(), |
| (DataObject) it4.next()); |
| } |
| } |
| else |
| { |
| deepCopyAssertions(sdo.getDataObject(p1), copiedSdo |
| .getDataObject(p2)); |
| } |
| } |
| try |
| { |
| sdo.get(p2); |
| assertTrue(false); |
| } |
| catch(Exception e) |
| { |
| // expected route |
| } |
| try |
| { |
| copiedSdo.get(p1); |
| assertTrue(false); |
| } |
| catch(Exception e2) |
| { |
| // expected route |
| } |
| } |
| |
| indent--; |
| } |
| |
| /* |
| private void indent() |
| { |
| for(int i=0; i <indent; i++) System.out.print(" "); |
| } |
| */ |
| |
| protected void constructSourceTree(DataFactory df) |
| { |
| // Create Instances |
| bankSDO = df.create(TEST_NAMESPACE, BANK_TYPE ); |
| branchSDO1 = df.create(TEST_NAMESPACE, BRANCH_TYPE ); |
| branchSDO2 = df.create(TEST_NAMESPACE, BRANCH_TYPE ); |
| serviceSDO1 = df.create(TEST_NAMESPACE, SERVICE_TYPE ); |
| serviceSDO2 = df.create(TEST_NAMESPACE, SERVICE_TYPE ); |
| serviceSDO3 = df.create(TEST_NAMESPACE, SERVICE_TYPE ); |
| customerSDO1 = df.create(TEST_NAMESPACE, CUSTOMER_TYPE ); |
| customerSDO2 = df.create(TEST_NAMESPACE, CUSTOMER_TYPE ); |
| customerSDO3 = df.create(TEST_NAMESPACE, CUSTOMER_TYPE ); |
| customerSDO4 = df.create(TEST_NAMESPACE, CUSTOMER_TYPE ); |
| |
| // Populate the Bank Instance |
| bankSDO.set("name", "Fourth National"); |
| Vector v = new Vector(); |
| v.add(branchSDO1); |
| v.add(branchSDO2); |
| bankSDO.set("Branch",v); |
| v.removeAllElements(); |
| v.add(serviceSDO1); |
| v.add(serviceSDO2); |
| v.add(serviceSDO3); |
| bankSDO.set("Service",v); |
| v.removeAllElements(); |
| v.add(customerSDO1); |
| v.add(customerSDO2); |
| v.add(customerSDO3); |
| v.add(customerSDO4); |
| bankSDO.set("Customer",v); |
| v.removeAllElements(); |
| |
| // Populate Branch Instances |
| // Branch 1 |
| branchSDO1.set("ID", "BR100"); |
| DataObject addr = df.create(TEST_NAMESPACE, ADDRESS_TYPE ); |
| addr.set("Street", "1302 Money Street"); |
| addr.set("City", "Apex"); |
| addr.set("State", "NC"); |
| addr.set("Zip", "27502"); |
| branchSDO1.set("Address", addr); |
| v.add("If you are north, head south"); |
| v.add("If you are south, head north"); |
| branchSDO1.set("Directions", v); |
| v.removeAllElements(); |
| DataObject account1 = df.create(TEST_NAMESPACE, ACCOUNT_TYPE ); |
| account1.set("ID", "0000 1200 0001"); |
| account1.set("Service", serviceSDO1 ); |
| account1.setBigDecimal("Balance", new BigDecimal("3124.12")); |
| v.add(account1); |
| DataObject account2 = df.create(TEST_NAMESPACE, ACCOUNT_TYPE ); |
| account2.set("ID", "0000 8899 0001"); |
| account2.set("Service", serviceSDO1 ); |
| account2.setBigDecimal("Balance", new BigDecimal("20.00")); |
| v.add(account2); |
| DataObject account3 = df.create(TEST_NAMESPACE, ACCOUNT_TYPE ); |
| account3.set("ID", "0000 3110 0020"); |
| account3.set("Service", serviceSDO3 ); |
| account3.setBigDecimal("Balance", new BigDecimal("5000.00")); |
| v.add(account3); |
| branchSDO1.set("Account", v); |
| v.removeAllElements(); |
| // Branch 2 |
| branchSDO2.set("ID", "BR200"); |
| addr = df.create(TEST_NAMESPACE, ADDRESS_TYPE ); |
| addr.set("Street", "1207 Cash Court"); |
| addr.set("City", "Raleigh"); |
| addr.set("State", "NC"); |
| addr.set("Zip", "27701"); |
| branchSDO2.set("Address", addr); |
| v.add("If you are east, head west"); |
| v.add("If you are west, head east"); |
| branchSDO2.set("Directions", v); |
| v.removeAllElements(); |
| DataObject account4 = df.create(TEST_NAMESPACE, ACCOUNT_TYPE ); |
| account4.set("ID", "0000 0011 0001"); |
| account4.set("Service", serviceSDO1 ); |
| account4.setBigDecimal("Balance", new BigDecimal("99.12")); |
| v.add(account4); |
| DataObject account5 = df.create(TEST_NAMESPACE, ACCOUNT_TYPE ); |
| account5.set("ID", "0000 9911 0001"); |
| account5.set("Service", serviceSDO2 ); |
| account5.setBigDecimal("Balance", new BigDecimal("820.00")); |
| v.add(account5); |
| DataObject account6 = df.create(TEST_NAMESPACE, ACCOUNT_TYPE ); |
| account6.set("ID", "0000 0001 0020"); |
| account6.set("Service", serviceSDO3 ); |
| account6.setBigDecimal("Balance", new BigDecimal("9000.00")); |
| v.add(account6); |
| branchSDO2.set("Account", v); |
| v.removeAllElements(); |
| |
| // Populate Service Instances |
| serviceSDO1.set("ID", "SRV01"); |
| serviceSDO1.set("Name", "Checking"); |
| serviceSDO1.setBigDecimal("Fee", new BigDecimal("0.00")); |
| serviceSDO2.set("ID", "SRV02"); |
| serviceSDO2.set("Name", "Savings"); |
| serviceSDO2.setBigDecimal("Fee", new BigDecimal("0.00")); |
| serviceSDO3.set("ID", "SRV03"); |
| serviceSDO3.set("Name", "Loan"); |
| serviceSDO3.setBigDecimal("Fee", new BigDecimal("0.00")); |
| |
| // Populate Customer Instances |
| // Customer 1 |
| customerSDO1.set("ID", "CUST01"); |
| customerSDO1.set("First", "James"); |
| customerSDO1.set("Last", "Madison"); |
| addr = df.create(TEST_NAMESPACE, ADDRESS_TYPE ); |
| addr.set("Street", "1234 Easy Street"); |
| addr.set("City", "New York"); |
| addr.set("State", "NY"); |
| addr.set("Zip", "27511"); |
| customerSDO1.set("Address", addr); |
| customerSDO1.set("HomeBranch", branchSDO1); |
| v.add(account1); |
| customerSDO1.set("Account", v); |
| v.removeAllElements(); |
| v.add(customerSDO2); |
| v.add(customerSDO3); |
| customerSDO1.set("Related", v); |
| v.removeAllElements(); |
| // Customer 2 |
| customerSDO2.set("ID", "CUST02"); |
| customerSDO2.set("First", "George"); |
| customerSDO2.set("Last", "Washington"); |
| addr = df.create(TEST_NAMESPACE, ADDRESS_TYPE ); |
| addr.set("Street", "1776 Potomac Avenue"); |
| addr.set("City", "Washington"); |
| addr.set("State", "DC"); |
| addr.set("Zip", "50555"); |
| customerSDO2.set("Address", addr); |
| customerSDO2.set("HomeBranch", branchSDO1); |
| v.add(account2); |
| v.add(account3); |
| customerSDO2.set("Account", v); |
| v.removeAllElements(); |
| // Customer 3 |
| customerSDO3.set("ID", "CUST03"); |
| customerSDO3.set("First", "Thomas"); |
| customerSDO3.set("Last", "Jefferson"); |
| addr = df.create(TEST_NAMESPACE, ADDRESS_TYPE ); |
| addr.set("Street", "1492 Columbus Avenue"); |
| addr.set("City", "Charlottesville"); |
| addr.set("State", "VA"); |
| addr.set("Zip", "20121"); |
| customerSDO3.set("Address", addr); |
| customerSDO3.set("HomeBranch", branchSDO2); |
| v.add(account4); |
| customerSDO3.set("Account", v); |
| v.removeAllElements(); |
| // Customer 4 |
| customerSDO4.set("ID", "CUST04"); |
| customerSDO4.set("First", "Benjamin"); |
| customerSDO4.set("Last", "Franklin"); |
| addr = df.create(TEST_NAMESPACE, ADDRESS_TYPE ); |
| addr.set("Street", "99 Light Street"); |
| addr.set("City", "Philadelphia"); |
| addr.set("State", "PA"); |
| addr.set("Zip", "19251"); |
| customerSDO4.set("Address", addr); |
| customerSDO4.set("HomeBranch", branchSDO2); |
| v.add(account5); |
| v.add(account6); |
| customerSDO4.set("Account", v); |
| v.removeAllElements(); |
| |
| } |
| |
| private void populateScopeWithDynamicTypes(TypeHelper scope) |
| { |
| Type stringType = scope.getType("commonj.sdo", "String"); |
| DataObject customerType = DataFactory.INSTANCE.create("commonj.sdo", "Type"); |
| customerType.set("uri", TEST_NAMESPACE); |
| customerType.set("name", DYNAMIC_TYPE ); |
| DataObject custNumProperty = customerType.createDataObject("property"); |
| custNumProperty.set("name", "custNum"); |
| custNumProperty.set("type", stringType); |
| DataObject firstNameProperty = customerType.createDataObject("property"); |
| firstNameProperty.set("name", "firstName"); |
| firstNameProperty.set("type", stringType); |
| DataObject lastNameProperty = customerType.createDataObject("property"); |
| lastNameProperty.set("name", "lastName"); |
| lastNameProperty.set("type", stringType); |
| scope.define(customerType); |
| } |
| |
| /* |
| private void dumpObject(DataObject sdo, String node ) |
| { |
| try |
| { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| SDOUtil.createXMLHelper(scopeA).save(sdo, TEST_NAMESPACE, |
| node, baos); |
| System.out.println(baos.toString()); |
| } |
| catch (IOException e) |
| { |
| e.printStackTrace(); |
| } |
| } |
| */ |
| } |