/*
 * 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.netbeans.modules.xml.axi;

import java.io.IOException;
import java.util.Iterator;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import junit.framework.*;
import org.netbeans.modules.xml.axi.impl.AttributeImpl;
import org.netbeans.modules.xml.axi.impl.AttributeProxy;
import org.netbeans.modules.xml.schema.model.Choice;
import org.netbeans.modules.xml.schema.model.ComplexExtension;
import org.netbeans.modules.xml.schema.model.ComplexTypeDefinition;
import org.netbeans.modules.xml.schema.model.GlobalAttributeGroup;
import org.netbeans.modules.xml.schema.model.GlobalComplexType;
import org.netbeans.modules.xml.schema.model.GlobalElement;
import org.netbeans.modules.xml.schema.model.LocalAttribute;
import org.netbeans.modules.xml.schema.model.SchemaModel;
import org.netbeans.modules.xml.schema.model.Sequence;
import org.netbeans.modules.xml.xam.dom.AbstractDocumentModel;


/**
 *
 * @author Ayub Khan
 */
public class SchemaTransformTest extends AbstractTestCase {
    
    public static final String LINE_RUSSIAN_DOLL_XSD   = "resources/line_RussianDoll.xsd";
    public static final String LINE_VENETIAN_BLIND_XSD = "resources/line_VenetianBlind.xsd";
    public static final String LINE_SALAMI_SLICE_XSD   = "resources/line_SalamiSlice.xsd";
    public static final String LINE_GARDEN_OF_EDEN_XSD = "resources/line_GardenOfEden.xsd";
    public static final String LOAN_APP_XSD   = "resources/LoanApplication.xsd";
    public static final String PO_XSD   = "resources/po.xsd";
    public static final String TYPES_XSD   = "resources/types.xsd";
    public static final String RECURSION_PO_XSD = "resources/recursion_po.xsd";
    public static final String ANNOTATION_XSD = "resources/annotation.xsd";
    public static final String NEWPO_XSD   = "resources/newpo.xsd";
    public static final String NEWPO1_XSD   = "resources/newpo1.xsd";
    public static final String COURIER_XSD   = "resources/courier.xsd";
    public static final String INCLUDE_XSD   = "resources/include.xsd";
    public static final String IMPORT_XSD   = "resources/import.xsd";
    public static final String ELEMENT_REUSE_XSD   = "resources/elementreuse.xsd";
    public static final String ELEMENT_REUSE1_XSD   = "resources/elementreuse1.xsd";
    public static final String ELEMENT_REUSE2_XSD   = "resources/elementreuse2.xsd";
    public static final String TYPE_REUSE_XSD   = "resources/typereuse.xsd";
    public static final String GLOBAL_ELEMENT   = "Line";
    
    private Document doc = null;
    
    public SchemaTransformTest(String testName) {
        super(testName, LINE_RUSSIAN_DOLL_XSD, GLOBAL_ELEMENT);
    }
    
    public static Test suite() {
//        TestSuite suite = new TestSuite(DesignPatternTest.class);
        TestSuite suite = new TestSuite();
        suite.addTest(new SchemaTransformTest("testFindUsageVisitor"));
        suite.addTest(new SchemaTransformTest("testLineGardenOfEden"));
        suite.addTest(new SchemaTransformTest("testLineSalamiSlice"));
        suite.addTest(new SchemaTransformTest("testLineVenetianBlind"));
        suite.addTest(new SchemaTransformTest("testLineRussianDoll"));
//        Disabled as referenced XSD file were partly not donated by oracle to apache
//        suite.addTest(new SchemaTransformTest("testTypes"));
        //FIXME suite.addTest(new SchemaTransformTest("testLoanApp"));
        suite.addTest(new SchemaTransformTest("testAnnotation"));
//        Disabled as referenced XSD file were partly not donated by oracle to apache
//        suite.addTest(new SchemaTransformTest("testPurchaseOrder"));
	//FIXME suite.addTest(new SchemaTransformTest("testDiscardTransform"));
        suite.addTest(new SchemaTransformTest("testRenameAfterTransform"));
//        Disabled as referenced XSD file were partly not donated by oracle to apache
//        suite.addTest(new SchemaTransformTest("testNewApproach"));
        suite.addTest(new SchemaTransformTest("testMultiSchemaInclude"));
        suite.addTest(new SchemaTransformTest("testMultiSchemaImport"));
        suite.addTest(new SchemaTransformTest("testGlobalElementReuse"));
        suite.addTest(new SchemaTransformTest("testGlobalElementReuse1"));
        //FIXME suite.addTest(new SchemaTransformTest("testGlobalElementReuse2"));
        suite.addTest(new SchemaTransformTest("testContentModelReuse"));
        return suite;
    }
    
    public void testFindUsageVisitor() {
        print("testFindUsageVisitor");
        try {
            loadModel(RECURSION_PO_XSD);
        } catch (Exception ex) {
            ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",2,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
    }
    
    public void testLineGardenOfEden() {
        print("testLineGardenOfEden");
        try {
            loadModel(LINE_RUSSIAN_DOLL_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",3,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",3,getSchemaModel().getSchema().getElements().size());
    }
    
    public void testLineSalamiSlice() {
        print("testLineSalamiSlice");
        try {
            loadModel(LINE_GARDEN_OF_EDEN_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",2,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",3,getSchemaModel().getSchema().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.SALAMI_SLICE);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",3,getSchemaModel().getSchema().getElements().size());
    }
    
    public void testLineVenetianBlind() {
        print("testLineVenetianBlind");
        try {
            loadModel(LINE_SALAMI_SLICE_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",3,getSchemaModel().getSchema().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.VENITIAN_BLIND);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",2,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
    }
    
    public void testLineRussianDoll() {
        print("testLineRussianDoll");
        try {
            loadModel(LINE_VENETIAN_BLIND_XSD);
        } catch (Exception ex) {
//			ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",1,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
    }
    
    public void testLoanApp() {
        print("testLoanApp");
        try {
            loadModel(LOAN_APP_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",7,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",2,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        //Transform from Venetian Blind to Russian Doll
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
            long end = System.currentTimeMillis();
            print("Time taken to transform from VB to RD: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",0,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        
        //Transform from Russian Doll to Venetian Blind
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.VENITIAN_BLIND);
            long end = System.currentTimeMillis();
            print("Time taken to transform from RD to VB: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",17,getSchemaModel().getSchema().getComplexTypes().size());
        //FIXME gives 19 instead of 8
//		assertEquals("global simple types",8,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",17,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        
        //Transform from Venetian Blind to Salami Slice
        try {
            long start = System.currentTimeMillis();
            
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.SALAMI_SLICE);
            long end = System.currentTimeMillis();
            print("Time taken to transform from VB to SS: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",58,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",0,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",58,axiModel.getRoot().getElements().size());
        
        //Transform from Salami Slice to Venetian Blind
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.VENITIAN_BLIND);
            long end = System.currentTimeMillis();
            print("Time taken to transform from SS to VB: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        
//		printDocument();
        assertEquals("global complex types",17,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",19,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",17,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        
        //Transform from Venetian Blind to Salami Slice
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
            long end = System.currentTimeMillis();
            print("Time taken to transform from VB to GE: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",18,getSchemaModel().getSchema().getComplexTypes().size());
        //FIXME should be 19 instead of 38
//		assertEquals("global simple types",19,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",58,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",18,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",58,axiModel.getRoot().getElements().size());
        
        //Transform from Salami Slice to Venetian Blind
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.VENITIAN_BLIND);
            long end = System.currentTimeMillis();
            print("Time taken to transform from GE to VB: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",17,getSchemaModel().getSchema().getComplexTypes().size());
        //FIXME should be 19 instead of 72
//		assertEquals("global simple types",19,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",17,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
    }
    
    public void testPurchaseOrder() {
        print("testPurchaseOrder");
        try {
            loadModel("resources/po.xsd");
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",7,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global attribute groups",2,getSchemaModel().getSchema().getAttributeGroups().size());
        assertEquals("global groups",2,getSchemaModel().getSchema().getGroups().size());
        assertEquals("global attributes",1,getSchemaModel().getSchema().getAttributes().size());
        assertEquals("global simple types",2,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",2,getSchemaModel().getSchema().getElements().size());
        
        //Transform from Garden of Eden to Russian Doll
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
            long end = System.currentTimeMillis();
            print("Time taken to transform from GE to RD: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        
        //TODO - validation fails due to ambigous schema po.xsd
//		validateSchema(axiModel.getSchemaModel());
        
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",0,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        
        
        //Transform from Russian Doll to Garden Of Eden
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
            long end = System.currentTimeMillis();
            print("Time taken to transform from RD to GE: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        
//		printDocument();
        assertEquals("global complex types",7,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",2,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",18,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",7,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",18,axiModel.getRoot().getElements().size());
        
        //Transform from Venetian Blind to Salami Slice
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.SALAMI_SLICE);
            long end = System.currentTimeMillis();
            print("Time taken to transform from GE to SS: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        //TODO - validation fails due to ambigous schema po.xsd
//		validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",18,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",0,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",18,axiModel.getRoot().getElements().size());
        
        //Transform from Salami Slice to Garden of Eden
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
            long end = System.currentTimeMillis();
            print("Time taken to transform from SS to GE: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        //TODO - validation fails due to ambigous schema po.xsd
//		validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",7,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",2,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",18,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",7,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",18,axiModel.getRoot().getElements().size());
        
        //Transform from Venetian Blind to Venetian Blind
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.VENITIAN_BLIND);
            long end = System.currentTimeMillis();
            print("Time taken to transform from GE to VB: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        //TODO - validation fails due to ambigous schema po.xsd
//		validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",6,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",2,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",6,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        
        //Transform from Venetian Blind to Garden of Eden
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
            long end = System.currentTimeMillis();
            print("Time taken to transform from VB to GE: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        //TODO - validation fails due to ambigous schema po.xsd
//		validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",7,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",2,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",18,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",7,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",18,axiModel.getRoot().getElements().size());
    }
    
    public void testTypes() {
        print("testLineGardenOfEden");
        try {
            loadModel(TYPES_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",3,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",7,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",3,getSchemaModel().getSchema().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
    
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",2,getSchemaModel().getSchema().getElements().size());
    }
    
    public void testAnnotation() {
        print("testAnnotation");
        try {
            loadModel(ANNOTATION_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",1,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
    }
    
    public void testDiscardTransform() {
        print("testDiscardTransform");
        try {
            loadModel(NEWPO1_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertPurchaseOrder();
        
        //save document contents
        Document doc = AbstractDocumentModel.class.cast(getSchemaModel()).getBaseDocument();
        String savedDoc = null;
        try {
            savedDoc = doc.getText(0, doc.getLength());
        } catch (BadLocationException ex) {
//			ex.printStackTrace();
        }
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",0,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        
        assertTrue(savedDoc != null);
        try {
            doc.remove(0, doc.getLength());
            doc.insertString(0, savedDoc, null);
//				axiModel.startTransaction();
            getSchemaModel().sync();
//				axiModel.endTransaction();
//			printDocument();
            axiModel.sync();
            String newDoc = doc.getText(0, doc.getLength());
            assertEquals("newDoc is not same as saveDoc", newDoc, savedDoc);
        } catch (BadLocationException ex) {
//				ex.printStackTrace();
            fail("failed");
        } catch (IOException ex) {
//				ex.printStackTrace();
            fail("failed");
        }
//		printDocument();
//		assertPurchaseOrder();
        
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
        } catch (IOException ex) {
            ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",0,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",3,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",2,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",6,getSchemaModel().getSchema().getElements().size());
    }
    
    private void assertPurchaseOrder() {
        assertEquals("global complex types",3,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",1,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",2,getSchemaModel().getSchema().getElements().size());
        
        Iterator itge = getSchemaModel().getSchema().getElements().iterator();
        GlobalElement po1 = (GlobalElement)itge.next();
        if(!po1.getName().equals("purchaseOrder"))
            po1 = (GlobalElement) itge.next();
        GlobalComplexType poType = (GlobalComplexType) po1.getType().get();
        ComplexTypeDefinition ctd = poType.getDefinition();
        ComplexExtension ce = (ComplexExtension) ctd.getChildren().get(0);
        GlobalComplexType poTypeBase = ((GlobalComplexType) ce.getBase().get());
        GlobalAttributeGroup ag = poTypeBase.getAttributeGroupReferences().
                iterator().next().getGroup().get();
        
        assertEquals("po's child compositor proxy",1, ce.getChildren(Choice.class).size());
        assertEquals("po's child compositor proxy",1, poTypeBase.getChildren(Sequence.class).size());
        assertEquals("po's attribute proxy",3, ag.getChildren(LocalAttribute.class).size());
        
        assertEquals("AXI content models",5,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",2,axiModel.getRoot().getElements().size());
        
        Element po = (Element)axiModel.getRoot().getElements().get(0);
        if(!po.getName().equals("purchaseOrder"))
            po = (Element)axiModel.getRoot().getElements().get(1);
        //since CompositorProxy extends Compositor, so use Compositor
        assertEquals("po's child compositor proxy",2, po.getChildren(Compositor.class).size());
        assertEquals("po's attribute proxy",3, po.getChildren(AttributeProxy.class).size());
        assertEquals("po's attribute",0, po.getChildren(AttributeImpl.class).size());
    }
    
    public void testRenameAfterTransform() {
        print("testRenameAfterTransform");
        try {
            loadModel(COURIER_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",1,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",1,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        
        //save document contents
        Document doc = AbstractDocumentModel.class.cast(getSchemaModel()).getBaseDocument();
        String savedDoc = null;
        try {
            savedDoc = doc.getText(0, doc.getLength());
        } catch (BadLocationException ex) {
//			ex.printStackTrace();
        }
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",0,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        
        Attribute first =
                (Attribute) axiModel.getRoot().getElements().get(0).
                getChildElements().get(0).getAttributes().get(0);
        axiModel.startTransaction();
        first.setName("first2");
        axiModel.endTransaction();
        
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.VENITIAN_BLIND);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
        
        Attribute first2 =
                (Attribute) axiModel.getRoot().getContentModels().get(0).
                getAttributes().get(0);
        axiModel.startTransaction();
        first2.setName("first3");
        axiModel.endTransaction();
        
        Attribute first3 =
                (Attribute) axiModel.getRoot().getElements().get(0).
                getChildElements().get(0).getAttributes().get(0);
        assertEquals("attr after rename", "first3", first3.getName());
        
//		printDocument();
        assertEquals("global complex types",1,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",1,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
    }
    
    public void testNewApproach() {
        print("testLineGardenOfEden");
        try {
            loadModel(NEWPO_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        validateSchema(axiModel.getSchemaModel());
    
//		printDocument();
        assertEquals("global complex types",3,getSchemaModel().getSchema().getComplexTypes().size());
//        assertEquals("global simple types",2,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",13,getSchemaModel().getSchema().getElements().size());
    }
    
    public void testMultiSchemaInclude() {
        print("testMultiSchemaInclude");
        try {
            loadModel(INCLUDE_XSD);
        } catch (Exception ex) {
            ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        assertEquals("global complex types",1,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",1,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        assertEquals("global complex types",1,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",3,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",1,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",3,axiModel.getRoot().getElements().size());
    }
    
    public void testMultiSchemaImport() {
        print("testMultiSchemaInclude");
        try {
            loadModel(IMPORT_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        assertEquals("global complex types",1,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",1,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        assertEquals("global complex types",1,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",3,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",1,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",3,axiModel.getRoot().getElements().size());
        
        try {
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.RUSSIAN_DOLL);
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",0,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",1,axiModel.getRoot().getElements().size());
    }
    
    public void testGlobalElementReuse() {
        print("testGlobalElementReuse");
        try {
            loadModel(ELEMENT_REUSE_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        //Transform from Garden of Eden to Russian Doll
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
            long end = System.currentTimeMillis();
            print("Time taken to transform from GE to RD: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        
        assertEquals("global complex types",4,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",5,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",4,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",5,axiModel.getRoot().getElements().size());
    }
    
    public void testGlobalElementReuse1() {
        print("testGlobalElementReuse1");
        try {
            loadModel(ELEMENT_REUSE1_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",0,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        //Transform from Garden of Eden to Russian Doll
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
            long end = System.currentTimeMillis();
            print("Time taken to transform from GE to RD: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        
        assertEquals("global complex types",3,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",4,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",3,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",4,axiModel.getRoot().getElements().size());
        
        Iterator it = getSchemaModel().getSchema().getElements().iterator();
        assertEquals("global elements","newElement",((GlobalElement)it.next()).getName());
        assertEquals("global elements","newElement1",((GlobalElement)it.next()).getName());
        assertEquals("global elements","newElement2",((GlobalElement)it.next()).getName());
        assertEquals("global elements","newElement3",((GlobalElement)it.next()).getName());
        
        Iterator it2 = getSchemaModel().getSchema().getComplexTypes().iterator();
        assertEquals("global elements","newElementType",((GlobalComplexType)it2.next()).getName());
        assertEquals("global elements","newElementType1",((GlobalComplexType)it2.next()).getName());
        assertEquals("global elements","newElementType2",((GlobalComplexType)it2.next()).getName());
    }
    
    public void testGlobalElementReuse2() {
        print("testGlobalElementReuse2");
        try {
            loadModel(ELEMENT_REUSE2_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",1,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        //Transform from Garden of Eden to Russian Doll
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
            long end = System.currentTimeMillis();
            print("Time taken to transform from GE to RD: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        
        assertEquals("global complex types",2,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",3,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",2,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",3,axiModel.getRoot().getElements().size());
    }
    
    public void testContentModelReuse() {
        print("testContentModelReuse");
        try {
            loadModel(TYPE_REUSE_XSD);
        } catch (Exception ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
        assertEquals("global complex types",1,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",1,getSchemaModel().getSchema().getElements().size());
        
        //Transform from Garden of Eden to Russian Doll
        try {
            long start = System.currentTimeMillis();
            SchemaGeneratorFactory.getDefault().transformSchema(
                    axiModel.getSchemaModel(), SchemaGenerator.Pattern.GARDEN_OF_EDEN);
            long end = System.currentTimeMillis();
            print("Time taken to transform from GE to RD: "+(end-start)+"ms");
        } catch (IOException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
//		printDocument();
        
        assertEquals("global complex types",2,getSchemaModel().getSchema().getComplexTypes().size());
        assertEquals("global simple types",0,getSchemaModel().getSchema().getSimpleTypes().size());
        assertEquals("global elements",5,getSchemaModel().getSchema().getElements().size());
        
        assertEquals("AXI content models",2,axiModel.getRoot().getContentModels().size());
        assertEquals("AXI global elements",5,axiModel.getRoot().getElements().size());
        
        Iterator it = getSchemaModel().getSchema().getElements().iterator();
        assertEquals("global elements","test",((GlobalElement)it.next()).getName());
        assertEquals("global elements","street",((GlobalElement)it.next()).getName());
        assertEquals("global elements","name",((GlobalElement)it.next()).getName());
        assertEquals("global elements","city",((GlobalElement)it.next()).getName());
        assertEquals("global elements","state",((GlobalElement)it.next()).getName());
        
        Iterator it2 = getSchemaModel().getSchema().getComplexTypes().iterator();
        assertEquals("global elements","testType",((GlobalComplexType)it2.next()).getName());
        assertEquals("global elements","nameType",((GlobalComplexType)it2.next()).getName());
    }
    
    private void printDocument() {
        try {
            SchemaModel sm = getSchemaModel();
            doc = ((AbstractDocumentModel)sm).getBaseDocument();
            System.out.println("doc: "+doc.getText(0, doc.getLength()));
        } catch (BadLocationException ex) {
            //ex.printStackTrace();
            assertTrue("Should not be here", false);
        }
    }
    
}