/*******************************************************************************
 * Copyright (c) 1998, 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation from Oracle TopLink
 ******************************************************************************/  

package org.eclipse.persistence.testing.sdo.model.datagraph;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.xml.namespace.QName;

import junit.textui.TestRunner;

import org.eclipse.persistence.sdo.SDODataGraph;
import org.eclipse.persistence.sdo.SDODataObject;
import org.eclipse.persistence.sdo.helper.DefaultSchemaLocationResolver;
import org.eclipse.persistence.sdo.helper.ListWrapper;
import org.eclipse.persistence.sdo.helper.SDOXSDHelper;

import commonj.sdo.DataGraph;
import commonj.sdo.DataObject;
import commonj.sdo.Type;

public class SDODataGraphDataObjectBackPointerTest extends SDODataGraphDataObjectTestCases {
    /**
     * customer/item[] - containment = true 
     * porder/item[] - containment = false
     */

    public SDODataGraphDataObjectBackPointerTest(String name) {
        super(name);
    }

    public void setUp() {
        super.setUp();
        dataGraph = new SDODataGraph(aHelperContext);
    }

    // This function will exercise the updateDataGraph() function on SDODataObject.updateContainment()
    public void testSetDOFromOtherDataGraphWithMixedContainmentNonContainmentWithoutCStoDGwithoutCS() {
    	DefaultSchemaLocationResolver resolver = new DefaultSchemaLocationResolver(new HashMap<QName, String>());
    	registerTypes();
    	List<Type> types = getTypesToGenerateFrom();
        ((SDOXSDHelper)xsdHelper).generate(types, resolver);
        
        // Create target
    	DataObject aDataObjectTarget = createRootObject(types);
    	DataGraph aDataGraphTarget = dataGraph;
    	aDataGraphTarget.createRootObject(aDataObjectTarget.getType());
    	DataObject targetRoot = aDataGraphTarget.getRootObject();
    	// Check it
    	assertNotNull(targetRoot);
    	assertEquals(targetRoot.getType(), aDataGraphTarget.getType(URINAME, COMPANY_TYPENAME));    	
    	ListWrapper pOrdersTarget = (ListWrapper)targetRoot.getList(PO_PATH);
    	int poSize = pOrdersTarget.size();
    	assertEquals(0, poSize);
    	
        // Create source
    	DataObject aDataObjectSource = createRootObject(types);
    	DataGraph aDataGraphSource = new SDODataGraph(aHelperContext);
    	aDataGraphSource.createRootObject(aDataObjectSource.getType());
    	DataObject sourceRoot = aDataGraphSource.getRootObject();
    	// Check it
    	assertNotNull(sourceRoot);
    	assertEquals(sourceRoot.getType(), aDataGraphSource.getType(URINAME, COMPANY_TYPENAME));    	
    	ListWrapper pOrdersSource = (ListWrapper) aDataObjectSource.getList(PO_PATH);
    	int poSizeSource = pOrdersSource.size();
    	assertEquals(1, poSizeSource);

    	// Clear the target CS so that we enter only the DataGraph recursive loop
    	((SDODataObject)targetRoot)._setChangeSummary(null);
    	
    	// Get source DO
    	DataObject sourcePO = (DataObject)pOrdersSource.get(0);
    	
    	// DataGraph should be null before set
    	assertNull(sourcePO.getDataGraph());
    	
    	// Move the root object from one null data graph to the other
    	pOrdersTarget.add(sourcePO);

    	// DataGraph should be not be null before set
    	assertNotNull(sourcePO.getDataGraph());
    	// Target dataGraph should be set on all children
    	assertEquals(aDataGraphTarget, sourcePO.getDataGraph());

    	DataObject copyPOshipTo = (DataObject)sourcePO.get("shipTo");
    	DataObject copyPObillTo = (DataObject)sourcePO.get("billTo");
    	DataObject copyPOitem1 = (DataObject)sourcePO.get("item[1]");
    	DataObject copyPOitem2 = (DataObject)sourcePO.get("item[2]");
    	
    	// Check dataGraph back pointers recursively (containment only)
    	List<DataObject> copyPreOrderList = preOrderTraversalDataObjectList(sourcePO);
    	assertNotNull(copyPreOrderList);
    	assertEquals(5, copyPreOrderList.size());
    	copyPreOrderList.contains(copyPOshipTo);
    	copyPreOrderList.contains(copyPObillTo);
    	copyPreOrderList.contains(copyPOitem1);
    	copyPreOrderList.contains(copyPOitem2);

    	assertNotNull(copyPOshipTo.getDataGraph());
    	assertEquals(aDataGraphTarget, copyPOshipTo.getDataGraph());
    	assertNotNull(copyPObillTo.getDataGraph());
    	assertEquals(aDataGraphTarget, copyPObillTo.getDataGraph());
    	// item property is unidirectional or containment=false - still in the dataGraph in this case
    	assertNotNull(copyPOitem1.getDataGraph());
    	assertEquals(aDataGraphTarget, copyPOitem1.getDataGraph());
    	assertNotNull(copyPOitem2.getDataGraph());
    	assertEquals(aDataGraphTarget, copyPOitem2.getDataGraph());
    }

    // This function will exercise the updateChangeSummaryAndDataGraph() function on SDODataObject.updateContainment()
    public void testSetDOFromOtherDataGraphWithMixedContainmentNonContainmentWithoutCStoDGwithCS() {
    	DefaultSchemaLocationResolver resolver = new DefaultSchemaLocationResolver(new HashMap<QName, String>());
    	registerTypes();
    	List<Type> types = getTypesToGenerateFrom();
        ((SDOXSDHelper)xsdHelper).generate(types, resolver);
        
        // Create target
    	DataObject aDataObjectTarget = createRootObject(types);
    	DataGraph aDataGraphTarget = dataGraph;
    	aDataGraphTarget.createRootObject(aDataObjectTarget.getType());
    	DataObject targetRoot = aDataGraphTarget.getRootObject();
    	// Check it
    	assertNotNull(targetRoot);
    	assertEquals(targetRoot.getType(), aDataGraphTarget.getType(URINAME, COMPANY_TYPENAME));    	
    	ListWrapper pOrdersTarget = (ListWrapper)targetRoot.getList(PO_PATH);
    	int poSize = pOrdersTarget.size();
    	assertEquals(0, poSize);
    	
    	// Add a porder (null DG source)
    	
        // Create source
    	DataObject aDataObjectSource = createRootObject(types);
    	DataGraph aDataGraphSource = new SDODataGraph(aHelperContext);
    	aDataGraphSource.createRootObject(aDataObjectSource.getType());
    	DataObject sourceRoot = aDataGraphSource.getRootObject();
    	// Check it
    	assertNotNull(sourceRoot);
    	assertEquals(sourceRoot.getType(), aDataGraphSource.getType(URINAME, COMPANY_TYPENAME));    	
    	ListWrapper pOrdersSource = (ListWrapper) aDataObjectSource.getList(PO_PATH);
    	int poSizeSource = pOrdersSource.size();
    	assertEquals(1, poSizeSource);

    	// Get source DO
    	DataObject sourcePO = (DataObject)pOrdersSource.get(0);
    	
    	// DataGraph should be null before set
    	assertNull(sourcePO.getDataGraph());
    	
    	// Move the root object from one null data graph to the other
    	pOrdersTarget.add(sourcePO);

    	// DataGraph should be not be null before set
    	assertNotNull(sourcePO.getDataGraph());
    	// Target dataGraph should be set on all children    	
    	assertEquals(aDataGraphTarget, sourcePO.getDataGraph());

    	DataObject copyPOshipTo = (DataObject)sourcePO.get("shipTo");
    	DataObject copyPObillTo = (DataObject)sourcePO.get("billTo");
    	DataObject copyPOitem1 = (DataObject)sourcePO.get("item[1]");
    	DataObject copyPOitem2 = (DataObject)sourcePO.get("item[2]");
    	
    	// Check dataGraph back pointers recursively (containment only)
    	List<DataObject> copyPreOrderList = preOrderTraversalDataObjectList(sourcePO);
    	assertNotNull(copyPreOrderList);
    	assertEquals(5, copyPreOrderList.size());
    	copyPreOrderList.contains(copyPOshipTo);
    	copyPreOrderList.contains(copyPObillTo);
    	copyPreOrderList.contains(copyPOitem1);
    	copyPreOrderList.contains(copyPOitem2);

    	assertNotNull(copyPOshipTo.getDataGraph());
    	assertEquals(aDataGraphTarget, copyPOshipTo.getDataGraph());
    	assertNotNull(copyPObillTo.getDataGraph());
    	assertEquals(aDataGraphTarget, copyPObillTo.getDataGraph());
    	// item property is unidirectional or containment=false - still in the dataGraph in this case
    	assertNotNull(copyPOitem1.getDataGraph());
    	assertEquals(aDataGraphTarget, copyPOitem1.getDataGraph());
    	assertNotNull(copyPOitem2.getDataGraph());
    	assertEquals(aDataGraphTarget, copyPOitem2.getDataGraph());
    }
    
    public void testDetachNonContainmentDOwithMixedContainmentNonContainmentWithoutCStoDGwithCS() {
    	DefaultSchemaLocationResolver resolver = new DefaultSchemaLocationResolver(new HashMap<QName, String>());
    	registerTypes();
    	List<Type> types = getTypesToGenerateFrom();
        ((SDOXSDHelper)xsdHelper).generate(types, resolver);
        //log(generatedSchema);
    	dataGraph.createRootObject(URINAME, COMPANY_TYPENAME);//aDataObject.getType());
    	DataObject aWrappedDO = dataGraph.getRootObject();
    	assertNotNull(aWrappedDO);
    	// TODO
    	assertEquals(aWrappedDO.getType(), dataGraph.getType(URINAME, COMPANY_TYPENAME));

    	DataObject dgDO = populateRootDataGraphDataObject(dataGraph.getRootObject(), types);
    	ListWrapper pOrders = (ListWrapper)dgDO.getList(PO_PATH);
    	int poSize = pOrders.size();
    	assertEquals(1, poSize);

    	// Detach DO    	
    	DataObject porder1DO = (DataObject)pOrders.get(0);
    	int porder1ItemsSize = ((ListWrapper)porder1DO.get("item")).size();
    	DataObject ncItem1DO = (DataObject)(porder1DO).get("item[1]");
    	DataObject detachedDO = ncItem1DO;
    	ncItem1DO.detach();

    	
    	ListWrapper pOrdersDGList = (ListWrapper)dgDO.getList(PO_PATH); 
    	int poSizeDG =  pOrdersDGList.size();
    	assertEquals(porder1ItemsSize - 1, poSizeDG);
    	
    	assertEquals(null, detachedDO.getDataGraph());
    	DataObject copyPOitem2 = (DataObject)porder1DO.get("item[1]"); // Remaining item
    	/**
    	 * item property is unidirectional or containment=false - therefore not in the dataGraph.
    	 * However, if the item also has a containment=true reference to itself then it does reference the dataGraph
    	 */    	
    	assertNull(ncItem1DO.getDataGraph());
    	assertNotNull(copyPOitem2);
    	assertNull(copyPOitem2.getDataGraph());

    	// Check that the CS is not set on all nodes including non-containment ones
    	assertNull(ncItem1DO.getChangeSummary());
    	
    }

    public void testAddDOwithMixedContainmentNonContainmentWithoutCStoDGwithCS() {
    	DefaultSchemaLocationResolver resolver = new DefaultSchemaLocationResolver(new HashMap<QName, String>());
    	registerTypes();
    	List<Type> types = getTypesToGenerateFrom();
        ((SDOXSDHelper)xsdHelper).generate(types, resolver);
        //log(generatedSchema);
    	DataObject aDataObject = createRootObject(types);
    	dataGraph.createRootObject(aDataObject.getType());
    	DataObject aWrappedDO = dataGraph.getRootObject();
    	assertNotNull(aWrappedDO);
    	assertEquals(aWrappedDO.getType(), dataGraph.getType(URINAME, COMPANY_TYPENAME));
    	
    	DataObject dgDO = dataGraph.getRootObject();
    	ListWrapper pOrders = (ListWrapper)aDataObject.getList(PO_PATH);
    	int poSize = pOrders.size();
    	assertEquals(1, poSize);
    	
    	// Create detached DO
    	DataObject copyPO = (DataObject)pOrders.get(0);
    	
    	// Create a new ListWrapper and set it on the DG DO
    	List<DataObject> aList = new ArrayList<DataObject>();
    	aList.add(copyPO);
    	// Add DO to DG-DO - there is no existing elements
    	dgDO.set("porder", aList);
    	ListWrapper pOrdersDGList = (ListWrapper)dgDO.getList(PO_PATH); 
    	int poSizeDG =  pOrdersDGList.size();
    	// or
    	//pOrdersDGList.add(copyPO);
    	assertEquals(poSize, poSizeDG);
    	
    	assertEquals(dataGraph, copyPO.getDataGraph());
    	DataObject copyPOshipTo = (DataObject)copyPO.get("shipTo");
    	DataObject copyPObillTo = (DataObject)copyPO.get("billTo");
    	DataObject copyPOitem1 = (DataObject)copyPO.get("item[1]");
    	DataObject copyPOitem2 = (DataObject)copyPO.get("item[2]");
    	
    	// Check dataGraph back pointers recursively (containment only)
    	List<DataObject> copyPreOrderList = preOrderTraversalDataObjectList(copyPO);
    	assertNotNull(copyPreOrderList);
    	assertEquals(5, copyPreOrderList.size());
    	copyPreOrderList.contains(copyPOshipTo);
    	copyPreOrderList.contains(copyPObillTo);
    	copyPreOrderList.contains(copyPOitem1);
    	copyPreOrderList.contains(copyPOitem2);

//    	for(DataObject aDO : copyPreOrderList) {
//    		assertEquals(dataGraph, aDO.getDataGraph()); // Check containment=true|false nodes
//    	}
    	
    	assertNotNull(copyPOshipTo.getDataGraph());
    	assertNotNull(copyPObillTo.getDataGraph());
    	// item property is unidirectional or containment=false - still in the dataGraph in this case
    	assertNotNull(copyPOitem1.getDataGraph());
    	assertNotNull(copyPOitem2.getDataGraph());
    	
    	// Check that the CS is set on all nodes including non-containment ones
    	assertNotNull(copyPOitem1.getChangeSummary());
    	
    }

    public void testDetachDOwithMixedContainmentNonContainmentWithoutCStoDGwithCS() {
    	DefaultSchemaLocationResolver resolver = new DefaultSchemaLocationResolver(new HashMap<QName, String>());
    	registerTypes();
    	List<Type> types = getTypesToGenerateFrom();
        String generatedSchema = ((SDOXSDHelper)xsdHelper).generate(types, resolver);
        //log(generatedSchema);
    	dataGraph.createRootObject(URINAME, COMPANY_TYPENAME);//aDataObject.getType());
    	DataObject aWrappedDO = dataGraph.getRootObject();
    	assertNotNull(aWrappedDO);
    	// TODO
    	assertEquals(aWrappedDO.getType(), dataGraph.getType(URINAME, COMPANY_TYPENAME));

    	DataObject dgDO = populateRootDataGraphDataObject(dataGraph.getRootObject(), types);
    	ListWrapper pOrders = (ListWrapper)dgDO.getList(PO_PATH);
    	int poSize = pOrders.size();
    	assertEquals(1, poSize);

    	// Detach DO    	
    	DataObject detachedDO = (DataObject)pOrders.get(0);
    	detachedDO.detach();

    	
    	ListWrapper pOrdersDGList = (ListWrapper)dgDO.getList(PO_PATH); 
    	int poSizeDG =  pOrdersDGList.size();
    	assertEquals(poSize - 1, poSizeDG);
    	
    	assertEquals(null, detachedDO.getDataGraph());
    	DataObject copyPOshipTo = (DataObject)detachedDO.get("shipTo");
    	DataObject copyPObillTo = (DataObject)detachedDO.get("billTo");
    	DataObject copyPOitem1 = (DataObject)detachedDO.get("item[1]");
    	DataObject copyPOitem2 = (DataObject)detachedDO.get("item[2]");
/*    	
    	// Check dataGraph back pointers recursively (containment only)
    	List<DataObject> copyPreOrderList = preOrderTraversalDataObjectList(detachedDO);
    	assertNotNull(copyPreOrderList);
    	assertEquals(5, copyPreOrderList.size());
    	copyPreOrderList.contains(copyPOshipTo);
    	copyPreOrderList.contains(copyPObillTo);
    	copyPreOrderList.contains(copyPOitem1);
    	copyPreOrderList.contains(copyPOitem2);
*/
    	assertNull(copyPOshipTo.getDataGraph());
    	assertNull(copyPObillTo.getDataGraph());
    	/**
    	 * item property is unidirectional or containment=false - therefore not in the dataGraph.
    	 * However, if the item also has a containment=true reference to itself then it does reference the dataGraph
    	 */
    	assertNull(copyPOitem1.getDataGraph());
    	assertNull(copyPOitem2.getDataGraph());

    	// Check that the CS is not set on all nodes including non-containment ones
    	assertNull(copyPOitem1.getChangeSummary());
    	
    }

    public void testDeleteDOwithMixedContainmentNonContainmentWithoutCStoDGwithCS() {
    	DefaultSchemaLocationResolver resolver = new DefaultSchemaLocationResolver(new HashMap<QName, String>());
    	registerTypes();
    	List<Type> types = getTypesToGenerateFrom();
        ((SDOXSDHelper)xsdHelper).generate(types, resolver);
        //log(generatedSchema);
    	dataGraph.createRootObject(URINAME, COMPANY_TYPENAME);//aDataObject.getType());
    	DataObject aWrappedDO = dataGraph.getRootObject();
    	assertNotNull(aWrappedDO);
    	// TODO
    	assertEquals(aWrappedDO.getType(), dataGraph.getType(URINAME, COMPANY_TYPENAME));

    	DataObject dgDO = populateRootDataGraphDataObject(dataGraph.getRootObject(), types);
    	ListWrapper pOrders = (ListWrapper)dgDO.getList(PO_PATH);
    	int poSize = pOrders.size();
    	assertEquals(1, poSize);
    	
    	// save objects before they are split apart
    	DataObject detachedDO = (DataObject)pOrders.get(0);
    	DataObject copyPOshipTo = (DataObject)detachedDO.get("shipTo");
    	DataObject copyPObillTo = (DataObject)detachedDO.get("billTo");
    	DataObject copyPOitem1 = (DataObject)detachedDO.get("item[1]");
    	DataObject copyPOitem2 = (DataObject)detachedDO.get("item[2]");

    	// Delete DO    	
    	detachedDO.delete();
    	
    	ListWrapper pOrdersDGList = (ListWrapper)dgDO.getList(PO_PATH); 
    	int poSizeDG =  pOrdersDGList.size();
    	assertEquals(poSize - 1, poSizeDG);
    	
    	assertEquals(null, detachedDO.getDataGraph());
/*    	
    	// Check dataGraph back pointers recursively (containment only)
    	List<DataObject> copyPreOrderList = preOrderTraversalDataObjectList(detachedDO);
    	assertNotNull(copyPreOrderList);
    	assertEquals(5, copyPreOrderList.size());
    	copyPreOrderList.contains(copyPOshipTo);
    	copyPreOrderList.contains(copyPObillTo);
    	copyPreOrderList.contains(copyPOitem1);
    	copyPreOrderList.contains(copyPOitem2);
*/
    	assertNull(copyPOshipTo.getDataGraph());
    	assertNull(copyPObillTo.getDataGraph());
    	/**
    	 * item property is unidirectional or containment=false - therefore not in the dataGraph.
    	 * However, if the item also has a containment=true reference to itself then it does reference the dataGraph
    	 */
    	assertNull(copyPOitem1.getDataGraph());
    	assertNull(copyPOitem2.getDataGraph());

    	// Check that the CS is not set on all nodes including non-containment ones
    	assertNull(copyPOitem1.getChangeSummary());
    	
    }

    public void testUnsetDOwithMixedContainmentNonContainmentWithoutCStoDGwithCS() {
    	DefaultSchemaLocationResolver resolver = new DefaultSchemaLocationResolver(new HashMap<QName, String>());
    	registerTypes();
    	List<Type> types = getTypesToGenerateFrom();
        String generatedSchema = ((SDOXSDHelper)xsdHelper).generate(types, resolver);
        //log(generatedSchema);
    	dataGraph.createRootObject(URINAME, COMPANY_TYPENAME);//aDataObject.getType());
    	DataObject aWrappedDO = dataGraph.getRootObject();
    	assertNotNull(aWrappedDO);
    	// TODO
    	assertEquals(aWrappedDO.getType(), dataGraph.getType(URINAME, COMPANY_TYPENAME));

    	DataObject dgDO = populateRootDataGraphDataObject(dataGraph.getRootObject(), types);
    	ListWrapper pOrders = (ListWrapper)dgDO.getList(PO_PATH);
    	int poSize = pOrders.size();
    	assertEquals(1, poSize);

    	// Delete DO    	
    	DataObject detachedDO = (DataObject)pOrders.get(0);
    	dgDO.unset(PO_PATH + "[1]");
    	
    	ListWrapper pOrdersDGList = (ListWrapper)dgDO.getList(PO_PATH); 
    	int poSizeDG =  pOrdersDGList.size();
    	assertEquals(poSize - 1, poSizeDG);
    	
    	assertEquals(null, detachedDO.getDataGraph());
    	DataObject copyPOshipTo = (DataObject)detachedDO.get("shipTo");
    	DataObject copyPObillTo = (DataObject)detachedDO.get("billTo");
    	DataObject copyPOitem1 = (DataObject)detachedDO.get("item[1]");
    	DataObject copyPOitem2 = (DataObject)detachedDO.get("item[2]");
/*    	
    	// Check dataGraph back pointers recursively (containment only)
    	List<DataObject> copyPreOrderList = preOrderTraversalDataObjectList(detachedDO);
    	assertNotNull(copyPreOrderList);
    	assertEquals(5, copyPreOrderList.size());
    	copyPreOrderList.contains(copyPOshipTo);
    	copyPreOrderList.contains(copyPObillTo);
    	copyPreOrderList.contains(copyPOitem1);
    	copyPreOrderList.contains(copyPOitem2);
*/
    	assertNull(copyPOshipTo.getDataGraph());
    	assertNull(copyPObillTo.getDataGraph());
    	/**
    	 * item property is unidirectional or containment=false - therefore not in the dataGraph.
    	 * However, if the item also has a containment=true reference to itself then it does reference the dataGraph
    	 */
    	assertNull(copyPOitem1.getDataGraph());
    	assertNull(copyPOitem2.getDataGraph());

    	// Check that the CS is not set on all nodes including non-containment ones
    	assertNull(copyPOitem1.getChangeSummary());
    }
     
    //public void testDeleteFromDataGraph() {    }
    //public void testDetachFromDataGraph() {    }
    //public void testUnsetFromDataGraph() {    }
    //public void testMoveBetweenDataGraphsUsingSet() {    }
  
    
    /**
     * Adding a child dataObject to an existing rootDataObject on a dataGraph (with/without changeSummary(s))
     * 
     * Start: (add DO2 as a child of DO1 - adding DO2 to the DG)
     * (target DG and DO1)
     *   DG
     *   	--> DO1
     *   		--> (CS1) - variable below
     *   
     *   (single CS on source)
     *   DO2
     *   	---> (CS2) - variable below
     *   or (multiple CS)
     *   DO2
     *   	---> DO3
     *   		---> (CS3) - variable below
     *   	---> DO4
     *   		---> (CS4) - variable below
     *   
     * End: (any CS2,3,4 are not merged into the single CS1 on the DG - exception occurs)
     *   DG
     *   	--> DO1
     *   		--> DO2    
     *   	--> (CS1) - variable below
     * 
     * Use Cases:
     * Target DG:DO1	Source DO2:		Operation:															Results:
     * --------------------------------------------------------------------------------------------------------------------------------------
     * cs=0						cs=0					: add DO (no cs) child to DG (no cs)					: no cs operations 
     * cs=0						cs=1					: add DO (with 1 cs) child to DG (no cs)			: cs is not moved to DG - exception
     * cs=0						cs=n (multiple)	: add DO (with multi-cs) child to DG (no cs)		: cs(s) not merged, not moved to DG - exception
     * cs=1						cs=0					: add DO (no cs) child to DG (with cs)				: no cs operations
     * cs=1						cs=1					: add DO (with 1 cs) child to DG (with cs)			: cs not merged with DG cs - exception
     * cs=1						cs=n (multiple)	: add DO (with multi-cs) child to DG (with cs)	: cs(s) not merged with DG cs - exception
     * 
     */
    //public void testAddChildDOwithoutCStoDGwithoutCS() {   }   	
    //public void testAddChildDOwith1CStoDGwithoutCS() {    }
    //public void testAddChildDOwithMulitpleCStoDGwithoutCS() {    }
    //public void testAddChildDOwithoutCStoDGwithCS() {    }
    //public void testAddChildDOwith1CStoDGwithCS() {    }
    //public void testAddChildDOwithMulipleCStoDGwithCS() {    }

    /**
     * Perform all operations where isContainment() check is performed in SDODataObject - but with the DO inside a DG 
     * so that non-containment DO's are treated as containment while in the DataGraph scope.
     */
    
    public static void main(String[] args) {
        String[] arguments = { "-c", "org.eclipse.persistence.testing.sdo.model.datagraph.SDODataGraphDataObjectBackPointerTest" };
        TestRunner.main(arguments);
    }
    
}
