plugins/org.eclipse.wst.sse.sieditor.test/api/org/eclipse/wst/sse/sieditor/test/ui/v2/dt/DataTypesFormPageControllerJUnitTest.java

/*******************************************************************************
 * Copyright (c) 2010 SAP AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Emil Simeonov - initial API and implementation.
 *    Dimitar Donchev - initial API and implementation.
 *    Dimitar Tenev - initial API and implementation.
 *    Nevena Manova - initial API and implementation.
 *    Georgi Konstantinov - initial API and implementation.
 *******************************************************************************/
package org.eclipse.wst.sse.sieditor.test.ui.v2.dt;

import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.createNiceMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.isA;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.only;
import static org.mockito.Mockito.times;

import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.wst.sse.sieditor.command.common.AbstractNotificationOperation;
import org.eclipse.wst.sse.sieditor.command.common.DeleteSetCommand;
import org.eclipse.wst.sse.sieditor.command.emf.wsdl.InlineNamespaceCompositeCommand;
import org.eclipse.wst.sse.sieditor.command.emf.xsd.AddSimpleTypeCommand;
import org.eclipse.wst.sse.sieditor.command.emf.xsd.AddStructureTypeCommand;
import org.eclipse.wst.sse.sieditor.command.emf.xsd.InlineStructureTypeContentsCommand;
import org.eclipse.wst.sse.sieditor.command.emf.xsd.MakeAnonymousTypeGlobalCommand;
import org.eclipse.wst.sse.sieditor.command.emf.xsd.MakeGlobalTypeAnonymousCommand;
import org.eclipse.wst.sse.sieditor.core.common.IEnvironment;
import org.eclipse.wst.sse.sieditor.model.api.IModelObject;
import org.eclipse.wst.sse.sieditor.model.api.IModelRoot;
import org.eclipse.wst.sse.sieditor.model.api.INamedObject;
import org.eclipse.wst.sse.sieditor.model.api.INamespacedObject;
import org.eclipse.wst.sse.sieditor.model.api.IWsdlModelRoot;
import org.eclipse.wst.sse.sieditor.model.api.IXSDModelRoot;
import org.eclipse.wst.sse.sieditor.model.wsdl.api.IDescription;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IElement;
import org.eclipse.wst.sse.sieditor.model.xsd.api.ISchema;
import org.eclipse.wst.sse.sieditor.model.xsd.api.ISimpleType;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IStructureType;
import org.eclipse.wst.sse.sieditor.model.xsd.api.IType;
import org.eclipse.wst.sse.sieditor.model.xsd.impl.Schema;
import org.eclipse.wst.sse.sieditor.test.util.EasymockModelUtils;
import org.eclipse.wst.sse.sieditor.ui.DialogManager;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.extractwizard.ExtractNamespaceWizard;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.IDataTypesTreeNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.IElementNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.INamespaceNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.ISimpleTypeNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.IStructureTypeNode;
import org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.impl.ElementNode;
import org.eclipse.wst.sse.sieditor.ui.v2.nodes.ITreeNode;
import org.eclipse.xsd.XSDTypeDefinition;
import org.eclipse.xsd.impl.XSDComplexTypeDefinitionImpl;
import org.eclipse.xsd.impl.XSDSimpleTypeDefinitionImpl;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;

/**
 *
 * 
 */
public class DataTypesFormPageControllerJUnitTest {

    /**
     * @throws java.lang.Exception
     */
    @Before
    public void setUp() throws Exception {
    }

    /**
     * @throws java.lang.Exception
     */
    @After
    public void tearDown() throws Exception {
    }

    private static class TestDataTypesFormPageController extends DataTypesFormPageController {

        private boolean editAllowed; // flag determining the isEditAllowed
        // method return value
        private Object editedMatch; // used to confirm the object for which the
        // isEditAllowed check is called
        private IXSDModelRoot xsdModelRoot; // returned by the
        // getXSDModelRoot(ISchema) method
        private Object selectObjectMatch; // used to confirm the object fired
        // for selection
        private int fireNodeSelectionCounter; // counts the calls to
        // fireNodeSelectionEvent(IModelObject)
        private ISchema retrievedSchema; // the returned result of
        // getSchema(IModelObject)
        private int fireErrorMsgCounter; // counts the calls to
        private boolean isDeleteAllowed;
        private Object deleteMatch;
        private ITreeNode nextTreeNode;
        private ITreeNode nextTreeNodeMatch;
        private Object removeNodeMatch;
        private int editCounter;
        private IModelObject partOfDocumentMatch;
        private Boolean isPartOfEdittedDocument;
        private int partOfEditedDocCounter;
        private int isDeleteCounter;
        private int resourceReadOnlyCounter;
        private DialogManager dialogManagerMock;

        // fireErrorMsgEvent(String)

        public TestDataTypesFormPageController(final IModelRoot model, final boolean readOnly) {
            super(model, readOnly);
            editAllowed = true;
            isDeleteAllowed = true;
            dialogManagerMock = null;
        }

        public TestDataTypesFormPageController(final IModelRoot model, final boolean readOnly, DialogManager dialogManagerMock) {
            this(model, readOnly);
            this.dialogManagerMock = dialogManagerMock;
        }

        // the folowing 3 methods override manage the mocking of the
        // isEditAllowed method
        @Override
        protected boolean isEditAllowed(final Object editedObject) {
            assertEquals(editedMatch, editedObject);
            editCounter++;
            return editAllowed;
        }

        public void setEditAllowed(final boolean editAllowed) {
            this.editAllowed = editAllowed;
        }

        public void setEditedMatch(final Object editedMatch) {
            this.editedMatch = editedMatch;
        }

        @Override
        protected IXSDModelRoot getXSDModelRoot(final ISchema schema) {
            assertEquals(editedMatch, schema);
            return xsdModelRoot;
        }

        public void setRetrievedXsdModelRoot(final IXSDModelRoot xsdModelRoot) {
            this.xsdModelRoot = xsdModelRoot;
        }

        @Override
        public void fireTreeNodeSelectionEvent(final IModelObject modelObject) {
            assertEquals(selectObjectMatch, modelObject);
            fireNodeSelectionCounter++;
        }

        /**
         * //used to confirm the object fired for selection <br>
         * -set this object to assert that the same will be givven to the <br>
         * fireTreeNodeSelectionEvent(IModelObject) method
         * 
         * @param selectObjectMatch
         */
        public void setSelectObjectMatch(final Object selectObjectMatch) {
            this.selectObjectMatch = selectObjectMatch;
        }

        /**
         * used to set value of the field counting
         * "fireTreeNodeSelectionEvent(IModelObject) calls
         * 
         * @param fireNodeSelectionCounter
         */
        public void setFireNodeSelectionCounter(final int fireNodeSelectionCounter) {
            this.fireNodeSelectionCounter = fireNodeSelectionCounter;
        }

        /**
         * used to get value of the field counting
         * "fireTreeNodeSelectionEvent(IModelObject) calls
         * 
         * @param fireNodeSelectionCounter
         */
        public int getFireNodeSelectionCounter() {
            return fireNodeSelectionCounter;
        }

        @Override
        protected ISchema getSchema(final ITreeNode node) {
            if (retrievedSchema == null) {
                return super.getSchema(node);
            }
            return retrievedSchema;
        }

        public void setRetrievedSchema(final ISchema retrievedSchema) {
            this.retrievedSchema = retrievedSchema;
        }

        @Override
        public void fireShowErrorMsgEvent(final String message) {
            fireErrorMsgCounter++;
        }

        public void setFireErrorMsgCounter(final int i) {
            fireErrorMsgCounter = i;

        }

        @Override
        protected boolean isDeleteAllowed(final Object editedObject) {
            assertEquals(deleteMatch, editedObject);
            isDeleteCounter++;
            return isDeleteAllowed;
        }

        public void setDeleteMatch(final Object deleteMatch) {
            this.deleteMatch = deleteMatch;
        }

        public void setDeleteAllowed(final boolean isDeleteAllowed) {
            this.isDeleteAllowed = isDeleteAllowed;
        }

        @Override
        protected ITreeNode getNextTreeNode(final ITreeNode selectedTreeNode) {
            assertEquals(nextTreeNodeMatch, selectedTreeNode);
            return nextTreeNode;
        }

        public void setNextTreeNode(final ITreeNode nextTreeNode) {
            this.nextTreeNode = nextTreeNode;
        }

        public void setNextTreeNodeMatch(final ITreeNode nextTreeNodeMatch) {
            this.nextTreeNodeMatch = nextTreeNodeMatch;
        }

        @Override
        public void removeNodeAndItsChildrenFromMap(final ITreeNode treeNode) {
            assertEquals(removeNodeMatch, treeNode);
        }

        public void setRemoveNodeMatch(final Object removeNodeMatch) {
            this.removeNodeMatch = removeNodeMatch;
        }

        @Override
        public boolean isPartOfEdittedDocument(final IModelObject modelObject) {
            if (isPartOfEdittedDocument != null) {
                assertEquals(partOfDocumentMatch, modelObject);
                partOfEditedDocCounter++;
                return isPartOfEdittedDocument.booleanValue();
            }
            return super.isPartOfEdittedDocument(modelObject);
        }

        public int getPartOfEditedDocCounter() {
            return partOfEditedDocCounter;
        }

        public void setPartOfEditedDocCounter(final int partOfEditedDocCounter) {
            this.partOfEditedDocCounter = partOfEditedDocCounter;
        }

        public void setPartOfDocumentMatch(final IModelObject partOfDocumentMatch) {
            this.partOfDocumentMatch = partOfDocumentMatch;
        }

        public void setPartOfEdittedDocument(final Boolean isPartOfEdittedDocument) {
            this.isPartOfEdittedDocument = isPartOfEdittedDocument;
        }

        // for testing purpouses
        @Override
        public boolean isAddTypeEnabled(final IDataTypesTreeNode selectedNode) {
            return super.isAddTypeEnabled(selectedNode);
        }

        @Override
        public IModelObject getModelObject() {
            return super.getModelObject();
        }

        @Override
        public boolean isResourceReadOnly() {
            resourceReadOnlyCounter++;
            return readOnly;
        }

        public int getResourceReadOnlyCounter() {
            return resourceReadOnlyCounter;
        }

        public void setResourceReadOnlyCounter(final int resourceReadOnlyCounter) {
            this.resourceReadOnlyCounter = resourceReadOnlyCounter;
        }

        public void setReadOnly(final boolean readOnly) {
            this.readOnly = readOnly;
        }

        @Override
        protected DialogManager getDialogManager() {
            return dialogManagerMock;
        }
    }

    @Test
    public final void testGetSchema() {
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(createMock(IModelRoot.class),
                false);
        final INamespaceNode namespaceMock = createMock(INamespaceNode.class);
        final ISchema schemaMock = createMock(ISchema.class);
        expect(namespaceMock.getModelObject()).andReturn(schemaMock);
        replay(namespaceMock);
        assertEquals(schemaMock, controller.getSchema(namespaceMock));
        verify(namespaceMock);

        reset(namespaceMock);
        final ISimpleTypeNode simpleTypeNodeMock = createMock(ISimpleTypeNode.class);
        expect(simpleTypeNodeMock.getParent()).andReturn(namespaceMock);
        expect(namespaceMock.getModelObject()).andReturn(schemaMock);
        replay(simpleTypeNodeMock, namespaceMock);
        assertEquals(schemaMock, controller.getSchema(simpleTypeNodeMock));
        verify(simpleTypeNodeMock, namespaceMock);

        reset(namespaceMock);
        final IStructureTypeNode structureTypeNodeMock = createMock(IStructureTypeNode.class);
        expect(structureTypeNodeMock.getParent()).andReturn(namespaceMock);
        expect(namespaceMock.getModelObject()).andReturn(schemaMock);
        replay(structureTypeNodeMock, namespaceMock);
        assertEquals(schemaMock, controller.getSchema(structureTypeNodeMock));
        verify(structureTypeNodeMock, namespaceMock);

        reset(namespaceMock);
        final IElementNode elementNodeMock = createMock(IElementNode.class);
        final IDataTypesTreeNode parentMock = createMock(IDataTypesTreeNode.class);
        expect(elementNodeMock.getParent()).andReturn(parentMock);
        expect(parentMock.getParent()).andReturn(namespaceMock);
        expect(namespaceMock.getModelObject()).andReturn(schemaMock);
        replay(elementNodeMock, namespaceMock, parentMock);
        assertEquals(schemaMock, controller.getSchema(elementNodeMock));
        verify(elementNodeMock, namespaceMock, parentMock);
        assertEquals(null, controller.getSchema(createMock(ITreeNode.class)));
    }

    /**
     * Test method for
     * {@link org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController#getModelObject()}
     * .
     */
    @Test
    public final void testGetModelObject() {
        final IModelRoot modelRoot = createNiceMock(IModelRoot.class);
        TestDataTypesFormPageController controller = new TestDataTypesFormPageController(modelRoot, false);

        assertNull(controller.getModelObject());

        // if the model root is an IWisdlModelRoot
        final IWsdlModelRoot wsdlModelRootMock = createMock(IWsdlModelRoot.class);
        final IDescription descriptionMock = createMock(IDescription.class);
        expect(wsdlModelRootMock.getModelObject()).andReturn(descriptionMock);
        replay(wsdlModelRootMock);

        controller = new TestDataTypesFormPageController(wsdlModelRootMock, false);
        assertEquals(descriptionMock, controller.getModelObject());
        verify(wsdlModelRootMock);

        // if the model root is an IXSDModelRoot
        final IXSDModelRoot xsdModelRootMock = createMock(IXSDModelRoot.class);
        final ISchema schemaMock = createMock(ISchema.class);
        expect(xsdModelRootMock.getModelObject()).andReturn(schemaMock);
        replay(xsdModelRootMock);

        controller = new TestDataTypesFormPageController(xsdModelRootMock, false);
        assertEquals(schemaMock, controller.getModelObject());
        verify(xsdModelRootMock);
    }

    /**
     * Test method for
     * {@link org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController#getNextTreeNode(org.eclipse.wst.sse.sieditor.ui.v2.nodes.ITreeNode)}
     * .
     */
    @Test
    public final void testGetNextTreeNode() {
        final ITreeNode selectedNodeMock = createNiceMock(ITreeNode.class);
        final ITreeNode resultTreeNode = createNiceMock(ITreeNode.class);
        final Object[] siblingsMocks = new Object[] { createNiceMock(ITreeNode.class), selectedNodeMock,
                createNiceMock(ITreeNode.class) };

        class DataTypesFormPageControllerExt extends DataTypesFormPageController {
            private Object selectedNodeMatch;

            public DataTypesFormPageControllerExt(final IModelRoot model) {
                super(model, false);
            }

            @Override
            public ITreeNode getNextTreeNode(final ITreeNode selectedTreeNode) {
                return super.getNextTreeNode(selectedTreeNode);
            }

            @Override
            protected ITreeNode getNextSiblingTreeNode(final ITreeNode selectedTreeNode, final Object[] siblings) {
                assertEquals(selectedNodeMatch, selectedTreeNode);
                for (int i = 0; i < siblingsMocks.length; i++) {
                    assertEquals(siblingsMocks[i], siblings[i]);
                }
                return resultTreeNode;
            }

            public void setSelectedNodeMatch(final Object selectedNodeMatch) {
                this.selectedNodeMatch = selectedNodeMatch;
            }
        }
        ;

        DataTypesFormPageControllerExt controller = new DataTypesFormPageControllerExt(createMock(IXSDModelRoot.class));

        controller.setSelectedNodeMatch(selectedNodeMock);

        assertNull(controller.getNextTreeNode(null));
        // if the selected node has no parents but it is not a Namespace node
        expect(selectedNodeMock.getParent()).andReturn(null);

        replay(selectedNodeMock);
        boolean caughtFlag = false;
        try {
            controller.getNextTreeNode(selectedNodeMock);
        } catch (final InvalidParameterException e) {
            caughtFlag = true;
        }
        assertTrue(caughtFlag);
        verify(selectedNodeMock);

        // if the selected node hasn't got a parent but it is a namespace node
        final ITreeNode namespaceNodeMock = createMock(INamespaceNode.class);
        expect(namespaceNodeMock.getParent()).andReturn(null);
        replay(namespaceNodeMock);

        assertNull(controller.getNextTreeNode(namespaceNodeMock));

        // if the node has a parent
        reset(selectedNodeMock);

        final ITreeNode parentNodeMock = createMock(ITreeNode.class);
        expect(selectedNodeMock.getParent()).andReturn(parentNodeMock).times(2);
        expect(parentNodeMock.getChildren()).andReturn(siblingsMocks);
        replay(selectedNodeMock, parentNodeMock);

        assertEquals(resultTreeNode, controller.getNextTreeNode(selectedNodeMock));

        verify(selectedNodeMock, parentNodeMock);

        reset(namespaceNodeMock);

        final IWsdlModelRoot wsdlRootMock = createMock(IWsdlModelRoot.class);
        controller = new DataTypesFormPageControllerExt(wsdlRootMock);
        controller.setSelectedNodeMatch(namespaceNodeMock);

        final IDescription descriptionMock = createMock(IDescription.class);
        expect(wsdlRootMock.getDescription()).andReturn(descriptionMock);
        final List<ISchema> schemaList = new ArrayList<ISchema>();
        schemaList.add(createMock(ISchema.class));
        schemaList.add(createMock(ISchema.class));
        schemaList.add(createMock(ISchema.class));
        expect(descriptionMock.getContainedSchemas()).andReturn(schemaList);
        controller.getTreeNodeMapper().addToNodeMap(schemaList.get(0), (ITreeNode) siblingsMocks[0]);
        controller.getTreeNodeMapper().addToNodeMap(schemaList.get(1), (ITreeNode) siblingsMocks[1]);
        controller.getTreeNodeMapper().addToNodeMap(schemaList.get(2), (ITreeNode) siblingsMocks[2]);

        expect(namespaceNodeMock.getParent()).andReturn(null);
        expect(namespaceNodeMock.getCategories()).andReturn(ITreeNode.CATEGORY_MAIN).anyTimes();

        replay(namespaceNodeMock, wsdlRootMock, descriptionMock);

        assertEquals(resultTreeNode, controller.getNextTreeNode(namespaceNodeMock));

        verify(namespaceNodeMock, wsdlRootMock, descriptionMock);
    }

    /**
     * Test method for
     * {@link org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController#removeNodeAndItsChildrenFromMap(org.eclipse.wst.sse.sieditor.ui.v2.nodes.ITreeNode)}
     * .
     */
    @SuppressWarnings("boxing")
    @Test
    public final void testRemoveNodeNItsChildrenFromMap() {
        final DataTypesFormPageController controller = new DataTypesFormPageController(null, false);

        final ITreeNode rootTreeNodeMock = createNiceMock(ITreeNode.class);
        final IModelObject rootModelObjectMock = createNiceMock(IModelObject.class);

        final ITreeNode child1TreeNodeMock = createNiceMock(ITreeNode.class);
        final IModelObject child1ModelObjectMock = createNiceMock(IModelObject.class);
        final ITreeNode child2TreeNodeMock = createNiceMock(ITreeNode.class);
        final IModelObject child2ModelObjectMock = createNiceMock(IModelObject.class);
        final ITreeNode child1ChildTreeNodeMock = createNiceMock(ITreeNode.class);
        final IModelObject child1ChildModelObjectMock = createNiceMock(IModelObject.class);

        controller.getTreeNodeMapper().addToNodeMap(rootModelObjectMock, rootTreeNodeMock);
        controller.getTreeNodeMapper().addToNodeMap(child1ModelObjectMock, child1TreeNodeMock);
        controller.getTreeNodeMapper().addToNodeMap(child2ModelObjectMock, child2TreeNodeMock);
        controller.getTreeNodeMapper().addToNodeMap(child1ChildModelObjectMock, child1ChildTreeNodeMock);

        expect(rootTreeNodeMock.hasChildren()).andReturn(Boolean.valueOf(false));
        expect(rootTreeNodeMock.getModelObject()).andReturn(rootModelObjectMock).atLeastOnce();

        expect(rootTreeNodeMock.hasChildren()).andReturn(Boolean.valueOf(true));
        expect(rootTreeNodeMock.getChildren()).andReturn(new Object[] { child1TreeNodeMock, child2TreeNodeMock });

        expect(child1TreeNodeMock.hasChildren()).andReturn(Boolean.valueOf(true));
        expect(child1TreeNodeMock.getChildren()).andReturn(new Object[] { child1ChildTreeNodeMock });

        expect(child1ChildTreeNodeMock.hasChildren()).andReturn(Boolean.valueOf(false));
        expect(child1ChildTreeNodeMock.getModelObject()).andReturn(child1ChildModelObjectMock).atLeastOnce();

        expect(child1TreeNodeMock.getModelObject()).andReturn(child1ModelObjectMock).atLeastOnce();

        expect(child2TreeNodeMock.hasChildren()).andReturn(Boolean.valueOf(false));
        expect(child2TreeNodeMock.getModelObject()).andReturn(child2ModelObjectMock).atLeastOnce();

        replay(rootTreeNodeMock, child1TreeNodeMock, child2TreeNodeMock, child1ChildTreeNodeMock);

        assertNotNull(controller.getTreeNodeMapper().getTreeNode(rootModelObjectMock));

        controller.removeNodeAndItsChildrenFromMap(rootTreeNodeMock);

        assertNull(controller.getTreeNodeMapper().getTreeNode(rootModelObjectMock));

        controller.getTreeNodeMapper().addToNodeMap(rootModelObjectMock, rootTreeNodeMock);

        assertNotNull(controller.getTreeNodeMapper().getTreeNode(rootModelObjectMock));
        assertNotNull(controller.getTreeNodeMapper().getTreeNode(child1ModelObjectMock));
        assertNotNull(controller.getTreeNodeMapper().getTreeNode(child2ModelObjectMock));

        controller.removeNodeAndItsChildrenFromMap(rootTreeNodeMock);

        assertNull(controller.getTreeNodeMapper().getTreeNode(rootModelObjectMock));
        assertNull(controller.getTreeNodeMapper().getTreeNode(child1ModelObjectMock));
        assertNull(controller.getTreeNodeMapper().getTreeNode(child2ModelObjectMock));
        assertNull(controller.getTreeNodeMapper().getTreeNode(child1ChildModelObjectMock));

        verify(rootTreeNodeMock);
        verify(child1TreeNodeMock);
        verify(child2TreeNodeMock);
        verify(child1ChildTreeNodeMock);
    }

    @Test
    public final void testRemoveLocalElementRefGlobalFromMap() {
        final IElement elementMock = EasymockModelUtils.createIElementMockFromSameModel();
        final IStructureType typeMock = createMock(IStructureType.class);
        expect(elementMock.getType()).andReturn(typeMock).atLeastOnce();
        expect(typeMock.isElement()).andReturn(Boolean.valueOf(true));

        final DataTypesFormPageController controller = new DataTypesFormPageController(null, false);
        replay(elementMock, typeMock);

        // mock the behaviour of a Global Element
        final ITreeNode parentNode = createNiceMock(ITreeNode.class);
        replay(parentNode);

        final ElementNode node = new ElementNode(elementMock, parentNode, controller.getTreeNodeMapper()) {
            @Override
            public boolean hasChildren() {
                return false;
            }

            @Override
            public int getCategories() {
                return super.getCategories() | ITreeNode.CATEGORY_REFERENCE;
            }
        };
        controller.getTreeNodeMapper().addToNodeMap(elementMock, node);

        assertEquals(node, controller.getTreeNodeMapper().getTreeNode(elementMock));

        controller.removeNodeAndItsChildrenFromMap(node);

        assertNull(controller.getTreeNodeMapper().getTreeNode(elementMock));

        // mock the behaviour of a ComplexType
        reset(typeMock);
        expect(typeMock.isElement()).andReturn(Boolean.valueOf(false));
        replay(typeMock);

        controller.getTreeNodeMapper().removeNodeFromMap(elementMock);

        assertNull(controller.getTreeNodeMapper().getTreeNode(elementMock));
    }

    @Test
    public final void testRemoveLocalElementOfSimpleTypeFromMap() {
        final IElement elementMock = createNiceMock(IElement.class);
        expect(elementMock.getType()).andReturn(createMock(ISimpleType.class)).atLeastOnce();

        replay(elementMock);

        final DataTypesFormPageController controller = new DataTypesFormPageController(null, false);

        // mock the behaviour of a SimpleType
        final ITreeNode parentNode = createNiceMock(ITreeNode.class);
        replay(parentNode);

        final ElementNode node = new ElementNode(elementMock, parentNode, controller.getTreeNodeMapper());

        controller.getTreeNodeMapper().addToNodeMap(elementMock, node);

        assertEquals(node, controller.getTreeNodeMapper().getTreeNode(elementMock));

        controller.removeNodeAndItsChildrenFromMap(node);

        assertNull(controller.getTreeNodeMapper().getTreeNode(elementMock));

        verify(elementMock);
    }

    @Test
    public void isAddElementEnabledForStructureType_SimpleContent() {
        final IDataTypesTreeNode node = createMock(IDataTypesTreeNode.class);
        expect(node.getCategories()).andReturn(0);
        expect(node.isReadOnly()).andReturn(false);

        final IStructureType structureType = createMock(IStructureType.class);
        expect(node.getModelObject()).andReturn(structureType);
        expect(structureType.isComplexTypeSimpleContent()).andReturn(true);

        replay(node, structureType);

        final DataTypesFormPageController controller = new DataTypesFormPageController(null, false);
        assertFalse(controller.isAddElementEnabled(node));
    }

    @Test
    public void isAddElementEnabledForStructureType_ComplexContent() {
        final IDataTypesTreeNode node = createMock(IDataTypesTreeNode.class);
        expect(node.getCategories()).andReturn(0);
        expect(node.isReadOnly()).andReturn(false);

        final IStructureType structureType = createMock(IStructureType.class);
        expect(node.getModelObject()).andReturn(structureType);
        expect(structureType.isComplexTypeSimpleContent()).andReturn(false);
        expect(structureType.getComponent()).andReturn(null);
        expect(structureType.isElement()).andReturn(false);

        replay(node, structureType);

        final DataTypesFormPageController controller = new DataTypesFormPageController(null, false);
        assertTrue(controller.isAddElementEnabled(node));
    }

    /**
     * Test method for the handleAddElementActionInvalidAndGlobalElement() -
     * tests the logic verifying the parameters<br>
     * And if the method constructs a command adding an element for an ISchema
     * and calls selection of the new tree node. Does not verify if the command
     * is properly setup and executed. Does not verify if the newly created
     * element is the one to be selected. To do so, probably a plugin test
     * should be written.
     * 
     * {@link org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController#handleAddElementAction(org.eclipse.wst.sse.sieditor.ui.v2.nodes.ITreeNode)}
     * .
     * 
     * @throws ExecutionException
     */
    @Test
    public final void testHandleAddElementActionInvalidAndGlobalElement() throws ExecutionException {
        final IModelRoot modelRootMock = createMock(IWsdlModelRoot.class);
        final IEnvironment envMock = createMock(IEnvironment.class);
        expect(modelRootMock.getEnv()).andReturn(envMock).atLeastOnce();
        expect(envMock.getEditingDomain()).andReturn(null).atLeastOnce();
        try {
            expect(envMock.execute(isA(AddStructureTypeCommand.class))).andReturn(Status.OK_STATUS);
        } catch (final ExecutionException e) {
            fail();// this should never fail
        }

        final ITreeNode selectedNodeMock = createNiceMock(ITreeNode.class);
        expect(selectedNodeMock.getModelObject()).andReturn(null);

        replay(modelRootMock, selectedNodeMock, envMock);

        final TestDataTypesFormPageController dataTypesFormPageController = new TestDataTypesFormPageController(modelRootMock,
                false, mock(DialogManager.class));
        // checks the case when the selectedNode's model object is null
        boolean caught = false;
        try {
            dataTypesFormPageController.handleAddElementAction(selectedNodeMock);
        } catch (final IllegalArgumentException e) {
            caught = true;
        }
        assertTrue(caught);

        verify(selectedNodeMock);
        // when the model object of the selected node is read only or not
        // applicable of type ISchema
        reset(selectedNodeMock);
        // returns just a mock to test cases when isEditAllowed returns false,
        // or the model object is
        // not an applicable for the action
        final IModelObject modelObjectMock = createMock(IModelObject.class);
        expect(selectedNodeMock.getModelObject()).andReturn(modelObjectMock).atLeastOnce();
        replay(selectedNodeMock);
        dataTypesFormPageController.getTreeNodeMapper().addToNodeMap(modelObjectMock, selectedNodeMock);
        // when the node is read only
        dataTypesFormPageController.setEditedMatch(modelObjectMock);
        dataTypesFormPageController.setEditAllowed(false);
        dataTypesFormPageController.handleAddElementAction(selectedNodeMock);
        dataTypesFormPageController.setEditAllowed(true);
        // ...
        // test the case when the model object of the selected node is not an
        // acceptable parameter(for element addition)
        caught = false;
        try {
            dataTypesFormPageController.handleAddElementAction(selectedNodeMock);
        } catch (final IllegalStateException e) {
            caught = true;
        }
        assertTrue(caught);

        verify(selectedNodeMock);
        reset(selectedNodeMock);
        // returns ISchema mock to test the case when an element is added to a
        // schema
        final ISchema schemaMock = createNiceMock(ISchema.class);
        expect(schemaMock.getAllTypes("Element1")).andReturn(new IType[0]);
        expect(selectedNodeMock.getModelObject()).andReturn(schemaMock);
        final IXSDModelRoot xsdRootMock = createMock(IXSDModelRoot.class);
        expect(schemaMock.getModelRoot()).andReturn(xsdRootMock);
        expect(xsdRootMock.getEnv()).andReturn(envMock).atLeastOnce();
        replay(selectedNodeMock, xsdRootMock, schemaMock);
        // test with a wsdl model root
        dataTypesFormPageController.setEditedMatch(schemaMock);
        dataTypesFormPageController.setFireNodeSelectionCounter(0);
        dataTypesFormPageController.setSelectObjectMatch(null);
        dataTypesFormPageController.setRetrievedXsdModelRoot(xsdRootMock);
        dataTypesFormPageController.getTreeNodeMapper().addToNodeMap(schemaMock, selectedNodeMock);

        dataTypesFormPageController.handleAddElementAction(selectedNodeMock);

        // place here any code verifying command execution

        // case when the model object to which elements are added is an ISchema

        verify(modelRootMock);
        verify(selectedNodeMock);
        verify(xsdRootMock);
    }

    /*
     * Test method for the handleAddElementActionInvalidAndGlobalElement()
     * -tests creation of commands and attempt for execution for adding elements
     * to StructureTypes and anonymous type elements and calls selection of the
     * new tree node. Does not verify if the command is properly setup and
     * executed. Does not verify if the newly created element is the one to be
     * selected. To do so, probably a plugin test should be written. {@link
     * org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController#
     * handleAddSimpleTypeAction
     * (org.eclipse.wst.sse.sieditor.ui.v2.nodes.ITreeNode)}
     * 
     * TEST COVERED BY ActionsSelectionTest
     * 
     * @SuppressWarnings("boxing")
     * 
     * @Test public final void
     * testHandleAddElementActionToStructureTypeAndElement() { IXSDModelRoot
     * modelRootMock = createMock(IXSDModelRoot.class); IEnvironment envMock =
     * createMock(IEnvironment.class); ITreeNode selectedNodeMock =
     * createMock(ITreeNode.class); // when the model object of the slecdted
     * node is of type IStructyreType
     * 
     * expect(modelRootMock.getEnv()).andReturn(envMock).times(2);
     * expect(envMock.getEditingDomain()).andReturn(null); try {
     * expect(envMock.execute
     * (isA(AddElementCommand.class))).andReturn(Status.OK_STATUS); } catch
     * (ExecutionException e) { fail();// this should never fail }
     * 
     * IStructureType structureTypeMock = createMock(IStructureType.class);
     * expect(structureTypeMock.getModelRoot()).andReturn(modelRootMock);
     * expect(
     * structureTypeMock.getElements(isA(String.class))).andStubReturn(Collections
     * .emptyList());
     * expect(selectedNodeMock.getModelObject()).andReturn(structureTypeMock);
     * replay(selectedNodeMock, modelRootMock, envMock, structureTypeMock);
     * 
     * TestDataTypesFormPageController dataTypesFormPageController = new
     * TestDataTypesFormPageController(modelRootMock, false);
     * 
     * dataTypesFormPageController.setEditedMatch(structureTypeMock);
     * dataTypesFormPageController.handleAddElementAction(selectedNodeMock);
     * 
     * verify(selectedNodeMock, modelRootMock, envMock, structureTypeMock); //
     * when the model object of the slecdted node is of type IStructyreType
     * reset(selectedNodeMock, modelRootMock, envMock, structureTypeMock);
     * 
     * expect(modelRootMock.getEnv()).andReturn(envMock).times(2);
     * expect(envMock.getEditingDomain()).andReturn(null); try {
     * expect(envMock.execute
     * (isA(AddElementCommand.class))).andReturn(Status.OK_STATUS); } catch
     * (ExecutionException e) { fail();// this should never fail }
     * 
     * IElement elementMock = createMock(IElement.class);
     * 
     * expect(elementMock.getType()).andReturn(structureTypeMock);
     * expect(structureTypeMock.isAnonymous()).andReturn(Boolean.valueOf(true));
     * expect(elementMock.getModelRoot()).andReturn(modelRootMock);
     * expect(structureTypeMock
     * .getElements(isA(String.class))).andStubReturn(Collections.emptyList());
     * expect(selectedNodeMock.getModelObject()).andReturn(elementMock);
     * replay(selectedNodeMock, modelRootMock, envMock, elementMock,
     * structureTypeMock);
     * 
     * dataTypesFormPageController.setEditedMatch(elementMock);
     * dataTypesFormPageController.handleAddElementAction(selectedNodeMock);
     * 
     * verify(modelRootMock, selectedNodeMock, envMock, structureTypeMock); }
     */

    /**
     * Test Method tests the gandleAddSimpleTypeAction(ITreeNode) method - the
     * test verifies exceptional<br>
     * cases and creation of addSimpleTypeCommand. The test does not verify the
     * command execution, effect<br>
     * and command state. There is no check if the node intended to be selected
     * via fireTreeNodeSelectionEvent()
     */
    @Test
    public final void testHandleAddSimpleTypeAction() {
        final IModelRoot modelRootMock = createMock(IModelRoot.class);

        final ITreeNode selectedNodeMock = createNiceMock(ITreeNode.class);
        // when the model root is not an XSDModelRoot
        // when when isEditAllowed returns false
        final DialogManager dialogManagerMock = mock(DialogManager.class);
        TestDataTypesFormPageController controller = new TestDataTypesFormPageController(modelRootMock, false, dialogManagerMock);

        final ISchema schemaMock = createNiceMock(ISchema.class);
        replay(schemaMock, selectedNodeMock);
        controller.setRetrievedSchema(schemaMock);
        controller.setEditedMatch(schemaMock);
        controller.setEditAllowed(false);
        controller.setFireErrorMsgCounter(0);
        controller.getTreeNodeMapper().addToNodeMap(schemaMock, selectedNodeMock);

        // do test
        controller.handleAddSimpleTypeAction(selectedNodeMock);
        Mockito.verify(dialogManagerMock, times(1)).showStatusDialog(any(String.class), any(IStatus.class));

        // when the isEditAllowed returns true
        controller.setEditAllowed(true);
        controller.setRetrievedXsdModelRoot(null);
        controller.handleAddSimpleTypeAction(selectedNodeMock);
        Mockito.verify(dialogManagerMock, times(2)).showStatusDialog(any(String.class), any(IStatus.class));

        final IXSDModelRoot xsdModelRootMock = createNiceMock(IXSDModelRoot.class);

        // if the model root is an IXSDModelRoot and returns a null schema
        expect(xsdModelRootMock.getSchema()).andReturn(null);
        replay(xsdModelRootMock);

        controller = new TestDataTypesFormPageController(xsdModelRootMock, false);

        boolean caughtFlag = false;
        try {
            controller.handleAddSimpleTypeAction(selectedNodeMock);
        } catch (final IllegalArgumentException e) {
            caughtFlag = true;
        }
        assertTrue(caughtFlag);

        verify(xsdModelRootMock);
        // when isEditAllowed() returns true and a command is constructed and
        // executed
        reset(xsdModelRootMock);
        final IWsdlModelRoot wsdlModelRootMock = createNiceMock(IWsdlModelRoot.class);
        final ISchema schemaMock2 = createNiceMock(ISchema.class);
        expect(schemaMock2.getModelRoot()).andReturn(xsdModelRootMock);
        final IEnvironment envMock = createMock(IEnvironment.class);
        expect(xsdModelRootMock.getEnv()).andReturn(envMock).times(2);
        expect(envMock.getEditingDomain()).andReturn(null);
        try {
            expect(envMock.execute(isA(AddSimpleTypeCommand.class))).andReturn(Status.OK_STATUS);
        } catch (final ExecutionException e) {
            fail();// this line should never be called
        }
        final ITreeNode treeNodeMock = createNiceMock(ITreeNode.class);
        replay(xsdModelRootMock, envMock, schemaMock2, treeNodeMock);

        controller = new TestDataTypesFormPageController(wsdlModelRootMock, false);
        controller.setRetrievedSchema(schemaMock2);
        controller.setEditAllowed(true);
        controller.setEditedMatch(schemaMock2);
        controller.setRetrievedXsdModelRoot(xsdModelRootMock);
        controller.getTreeNodeMapper().addToNodeMap(schemaMock2, treeNodeMock);

        controller.handleAddSimpleTypeAction(selectedNodeMock);

        verify(xsdModelRootMock);
        verify(envMock);
    }

    /**
     * Test method for
     * {@link org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController#handleAddStructureTypeAction(org.eclipse.wst.sse.sieditor.ui.v2.nodes.ITreeNode)}
     * .
     */
    @Test
    public final void testHandleAddStructureTypeAction() {
        final IModelRoot modelRootMock = createMock(IModelRoot.class);

        final ITreeNode selectedNodeMock = createNiceMock(ITreeNode.class);
        replay(selectedNodeMock);
        DialogManager dialogManagerMock = mock(DialogManager.class);
        // when the model root is not an XSDModelRoot
        // when when isEditAllowed returns false
        TestDataTypesFormPageController controller = new TestDataTypesFormPageController(modelRootMock, false, dialogManagerMock);
        final ISchema schemaMock = createNiceMock(ISchema.class);
        replay(schemaMock);
        controller.setRetrievedSchema(schemaMock);
        controller.setEditedMatch(schemaMock);
        controller.setEditAllowed(false);
        controller.setFireErrorMsgCounter(0);
        controller.getTreeNodeMapper().addToNodeMap(schemaMock, selectedNodeMock);
        controller.handleAddStructureTypeAction(selectedNodeMock);
        Mockito.verify(dialogManagerMock, only()).showStatusDialog(any(String.class), any(IStatus.class));

        // when the isEditAllowed returns true
        controller.setEditAllowed(true);
        controller.setRetrievedXsdModelRoot(null);
        controller.handleAddStructureTypeAction(selectedNodeMock);
        Mockito.verify(dialogManagerMock, times(2)).showStatusDialog(any(String.class), any(IStatus.class));

        final IXSDModelRoot xsdModelRootMock = createNiceMock(IXSDModelRoot.class);

        // if the model root is an IXSDModelRoot and returns a null schema
        expect(xsdModelRootMock.getSchema()).andReturn(null);
        replay(xsdModelRootMock);

        controller = new TestDataTypesFormPageController(xsdModelRootMock, false);

        boolean caughtFlag = false;
        try {
            controller.handleAddStructureTypeAction(selectedNodeMock);
        } catch (final IllegalArgumentException e) {
            caughtFlag = true;
        }
        assertTrue(caughtFlag);

        verify(xsdModelRootMock);
        // when isEditAllowed() returns true and a command is constructed and
        // executed
        reset(xsdModelRootMock);

        final IEnvironment envMock = createMock(IEnvironment.class);
        expect(xsdModelRootMock.getEnv()).andReturn(envMock);
        try {
            expect(envMock.execute(isA(AddStructureTypeCommand.class))).andReturn(Status.OK_STATUS);
        } catch (final ExecutionException e) {
            fail();// this line should never be called
        }

        replay(xsdModelRootMock, envMock);
    }

    /**
     * Test method for
     * {@link org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController#handleRemoveAction(org.eclipse.wst.sse.sieditor.ui.v2.nodes.ITreeNode)}
     * .
     */
    @Test
    public final void testHandleRemoveAction() {
        final ITreeNode treeNodeMock = createMock(ITreeNode.class);
        final IModelObject modelObjectMock = createMock(IModelObject.class);
        final IEnvironment envMock = createMock(IEnvironment.class);
        IModelObject xsdComponentMock = createMock(ISchema.class);
        IModelRoot modelRootMock = createMock(IWsdlModelRoot.class);

        expect(modelRootMock.getEnv()).andReturn(envMock).times(2);
        expect(treeNodeMock.getModelObject()).andReturn(modelObjectMock).times(2);
        expect(modelObjectMock.getParent()).andReturn(null).anyTimes();
        expect(envMock.getEditingDomain()).andReturn(null).anyTimes();
        replay(treeNodeMock, modelRootMock, modelObjectMock, envMock);

        DialogManager dialogManagerMock = mock(DialogManager.class);
        TestDataTypesFormPageController controller = new TestDataTypesFormPageController(modelRootMock, false, dialogManagerMock);
        controller.setEditAllowed(false);
        controller.setEditedMatch(modelObjectMock);
        controller.handleRemoveAction(Arrays.asList(treeNodeMock));

        controller.setEditAllowed(true);
        controller.setFireErrorMsgCounter(0);
        controller.setNextTreeNodeMatch(treeNodeMock);

        controller.handleRemoveAction(Arrays.asList(treeNodeMock));

        Mockito.verify(dialogManagerMock, only()).showStatusDialog(any(String.class), any(IStatus.class));
        verify(treeNodeMock);

        // when a ISchema is to be removed
        reset(treeNodeMock);

        controller.setNextTreeNodeMatch(treeNodeMock);
        controller.setNextTreeNode(createMock(ITreeNode.class));
        controller.setRemoveNodeMatch(treeNodeMock);

        // case when a simple or complex type is to be removed
        reset(treeNodeMock, modelRootMock, envMock, modelObjectMock);

        xsdComponentMock = createMock(IType.class);
        prepairHandleRemoveCommandMocks(treeNodeMock, modelRootMock, envMock, xsdComponentMock, DeleteSetCommand.class,
                Status.OK_STATUS);
        expect(xsdComponentMock.getParent()).andReturn(createMock(ISchema.class)).anyTimes();

        replay(treeNodeMock, modelRootMock, envMock, modelObjectMock, xsdComponentMock);

        controller.setEditedMatch(xsdComponentMock);
        controller.handleRemoveAction((Arrays.asList(treeNodeMock)));

        verify(treeNodeMock, modelRootMock, envMock);
        // case when an element is to be removed
        reset(treeNodeMock, modelRootMock, envMock);

        xsdComponentMock = createMock(IElement.class);
        prepairHandleRemoveCommandMocks(treeNodeMock, modelRootMock, envMock, xsdComponentMock, DeleteSetCommand.class,
                Status.OK_STATUS);
        final IStructureType type = createMock(IStructureType.class);
        expect(xsdComponentMock.getParent()).andReturn(type).times(4);
        expect(type.getAllElements()).andReturn(Arrays.asList((IElement) xsdComponentMock)).anyTimes();
        expect(type.getParent()).andReturn(null).anyTimes();

        replay(treeNodeMock, modelRootMock, envMock, xsdComponentMock, type);

        controller.setEditedMatch(xsdComponentMock);
        controller.handleRemoveAction((Arrays.asList(treeNodeMock)));

        verify(treeNodeMock, modelRootMock, envMock, xsdComponentMock);

        // simulate command execution failure
        reset(treeNodeMock, modelRootMock, envMock, xsdComponentMock);
        prepairHandleRemoveCommandMocks(treeNodeMock, modelRootMock, envMock, xsdComponentMock, DeleteSetCommand.class,
                Status.CANCEL_STATUS);
        final IStructureType typeMock = createMock(IStructureType.class);
        expect(xsdComponentMock.getParent()).andReturn(typeMock).times(4);
        expect(typeMock.getAllElements()).andReturn(Arrays.asList((IElement) xsdComponentMock)).anyTimes();
        expect(typeMock.getParent()).andReturn(null).anyTimes();
        replay(treeNodeMock, modelRootMock, envMock, xsdComponentMock, typeMock);

        controller.setEditedMatch(xsdComponentMock);
        controller.handleRemoveAction((Arrays.asList(treeNodeMock)));

        verify(treeNodeMock, modelRootMock, envMock, xsdComponentMock);

        // tests the case when a schema is requested to be removed, but the
        // model root is not a Wsdl root but an xsd
        reset(treeNodeMock, modelRootMock, envMock, xsdComponentMock);

        modelRootMock = createMock(IModelRoot.class);
        xsdComponentMock = createMock(ISchema.class);
        expect(treeNodeMock.getModelObject()).andReturn(xsdComponentMock);
        expect(modelRootMock.getEnv()).andReturn(envMock).times(4);
        expect(envMock.getEditingDomain()).andReturn(null).times(3);
        expect(xsdComponentMock.getParent()).andReturn(null).anyTimes();

        replay(treeNodeMock, modelRootMock, envMock, xsdComponentMock);

        controller = new TestDataTypesFormPageController(modelRootMock, false, dialogManagerMock);
        controller.setEditedMatch(xsdComponentMock);
        controller.setNextTreeNodeMatch(treeNodeMock);
        controller.handleRemoveAction((Arrays.asList(treeNodeMock)));

        verify(treeNodeMock);
    }

    private void prepairHandleRemoveCommandMocks(final ITreeNode treeNodeMock, final IModelRoot modelRootMock,
            final IEnvironment envMock, final IModelObject xsdComponentMock,
            final Class<? extends AbstractNotificationOperation> commandToBeExecuted, final IStatus returnStatus) {
        expect(treeNodeMock.getModelObject()).andReturn(xsdComponentMock);
        expect(modelRootMock.getEnv()).andReturn(envMock).times(3);
        expect(envMock.getEditingDomain()).andReturn(null).times(2);

        try {
            expect(envMock.execute(isA(commandToBeExecuted))).andReturn(returnStatus);
        } catch (final ExecutionException e) {
            fail();
        }
    }

    /**
     * Test method for
     * {@link org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController#isRemoveItemEnabled(org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.IDataTypesTreeNode)}
     * .
     */
    @SuppressWarnings("boxing")
    @Test
    public final void testIsRemoveItemEnabled() {
        final IXSDModelRoot xsdRootMock = createMock(IXSDModelRoot.class);
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(xsdRootMock, false);
        assertFalse(controller.isRemoveItemsEnabled(null));

        ITreeNode parentNode = createMock(ITreeNode.class);
        expect(parentNode.isReadOnly()).andReturn(Boolean.valueOf(true)).anyTimes();
        replay(parentNode);

        IDataTypesTreeNode treeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(treeNodeMock.getParent()).andReturn(parentNode).anyTimes();

        replay(treeNodeMock);

        assertFalse(controller.isRemoveItemsEnabled(Arrays.asList(treeNodeMock)));

        verify(treeNodeMock);

        final List<Class<? extends IDataTypesTreeNode>> typesClassList = new ArrayList<Class<? extends IDataTypesTreeNode>>();
        typesClassList.add(ISimpleTypeNode.class);
        typesClassList.add(IStructureTypeNode.class);
        typesClassList.add(IElementNode.class);
        typesClassList.add(INamespaceNode.class);

        final IModelObject modelObjectMock = createMock(IModelObject.class);
        final ISchema schemaMock = createMock(ISchema.class);

        for (final Class<? extends IDataTypesTreeNode> type : typesClassList) {
            parentNode = createMock(ITreeNode.class);
            expect(parentNode.isReadOnly()).andReturn(Boolean.valueOf(false)).anyTimes();
            replay(parentNode);

            treeNodeMock = createMock(type);
            // when isDeleteAllowed is false
            expect(treeNodeMock.getParent()).andReturn(parentNode).anyTimes();
            replay(treeNodeMock);

            controller.setResourceReadOnlyCounter(0);
            controller.setReadOnly(true);

            controller.setPartOfDocumentMatch(modelObjectMock);
            controller.setPartOfEditedDocCounter(0);
            controller.setPartOfEdittedDocument(Boolean.valueOf(true));

            assertFalse(controller.isRemoveItemsEnabled(Arrays.asList(treeNodeMock)));
            assertTrue(controller.getResourceReadOnlyCounter() == 1);
            assertTrue(controller.getPartOfEditedDocCounter() == 0);

            verify(treeNodeMock);

            // when isPartOfEditedDocument is false
            reset(treeNodeMock);

            expect(treeNodeMock.getParent()).andReturn(parentNode).anyTimes();
            expect(treeNodeMock.getModelObject()).andReturn(modelObjectMock);
            replay(treeNodeMock);

            // when isDeleteAllowed returns true but isPartOfEdittedDocument is
            // false

            controller.setReadOnly(false);
            controller.setResourceReadOnlyCounter(0);
            controller.setPartOfEditedDocCounter(0);
            assertTrue(controller.isRemoveItemsEnabled((Arrays.asList(treeNodeMock))));
            assertTrue(controller.getResourceReadOnlyCounter() == 1);

            verify(treeNodeMock);

            // whent is part of edited doc is true, but model object is document
            // schema
            reset(treeNodeMock, xsdRootMock);

            expect(treeNodeMock.getParent()).andReturn(parentNode).anyTimes();
            expect(treeNodeMock.getModelObject()).andReturn(schemaMock).anyTimes();
            expect(xsdRootMock.getSchema()).andReturn(schemaMock).anyTimes();

            replay(treeNodeMock, xsdRootMock);

            controller.setResourceReadOnlyCounter(0);
            controller.setPartOfEdittedDocument(Boolean.valueOf(true));
            assertFalse(controller.isRemoveItemsEnabled(Arrays.asList(treeNodeMock)));
            assertTrue(controller.getResourceReadOnlyCounter() == 1);

            verify(treeNodeMock, xsdRootMock);

            reset(treeNodeMock);
            // when isDocumentSchema is false
            expect(treeNodeMock.getParent()).andReturn(parentNode).anyTimes();
            expect(treeNodeMock.getModelObject()).andReturn(modelObjectMock).anyTimes();

            replay(treeNodeMock);

            controller.setResourceReadOnlyCounter(0);
            assertTrue(controller.isRemoveItemsEnabled(Arrays.asList(treeNodeMock)));
            assertTrue(controller.getResourceReadOnlyCounter() == 1);

            verify(treeNodeMock);
        }
    }

    /**
     * Test method for
     * {@link org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController#isRenameItemEnabled(org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.IDataTypesTreeNode)}
     * .
     */
    @SuppressWarnings("boxing")
    @Test
    public final void testIsRenameItemEnabled() {
        final IXSDModelRoot xsdRootMock = createMock(IXSDModelRoot.class);
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(xsdRootMock, false);
        assertFalse(controller.isRenameItemEnabled(null));

        IDataTypesTreeNode treeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(treeNodeMock.isReadOnly()).andReturn(Boolean.valueOf(true));

        replay(treeNodeMock);

        assertFalse(controller.isRenameItemEnabled(treeNodeMock));

        verify(treeNodeMock);

        final List<Class<? extends IDataTypesTreeNode>> typesClassList = new ArrayList<Class<? extends IDataTypesTreeNode>>();
        typesClassList.add(ISimpleTypeNode.class);
        typesClassList.add(IStructureTypeNode.class);
        typesClassList.add(IElementNode.class);
        typesClassList.add(INamespaceNode.class);

        final INamedObject namedObjectMock = createMock(INamedObject.class);
        final INamespacedObject namespacedObjectMock = createMock(INamespacedObject.class);

        for (final Class<? extends IDataTypesTreeNode> type : typesClassList) {
            // when readOnly is true
            controller.setResourceReadOnlyCounter(0);
            controller.setReadOnly(true);

            controller.setPartOfDocumentMatch(namedObjectMock);
            controller.setPartOfEditedDocCounter(0);
            controller.setPartOfEdittedDocument(Boolean.valueOf(true));

            assertFalse(controller.isRenameItemEnabled(treeNodeMock));
            assertTrue(controller.getResourceReadOnlyCounter() == 1);
            assertTrue(controller.getPartOfEditedDocCounter() == 0);

            // when the edited model object is a namespaced model object and
            // isReadOnly == true
            treeNodeMock = createMock(type);

            controller.setResourceReadOnlyCounter(0);
            controller.setReadOnly(true);

            controller.setPartOfDocumentMatch(namespacedObjectMock);
            controller.setPartOfEditedDocCounter(0);
            controller.setPartOfEdittedDocument(Boolean.valueOf(true));

            assertFalse(controller.isRenameItemEnabled(treeNodeMock));
            assertTrue(controller.getResourceReadOnlyCounter() == 1);
            assertTrue(controller.getPartOfEditedDocCounter() == 0);

            // when isPartOfEditedDocument is false

            expect(treeNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false));
            expect(treeNodeMock.getModelObject()).andReturn(namedObjectMock).anyTimes();
            replay(treeNodeMock);

            controller.setResourceReadOnlyCounter(0);
            controller.setReadOnly(false);
            assertTrue(controller.isRenameItemEnabled(treeNodeMock));
            assertTrue(controller.getResourceReadOnlyCounter() == 1);

            verify(treeNodeMock);

            // whent is part of edited doc is true, but model object is document
            // schema
            reset(treeNodeMock, xsdRootMock);

            expect(treeNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false));
            expect(treeNodeMock.getModelObject()).andReturn(namespacedObjectMock).anyTimes();

            replay(treeNodeMock, xsdRootMock);

            controller.setResourceReadOnlyCounter(0);
            controller.setReadOnly(false);

            controller.setPartOfEdittedDocument(Boolean.valueOf(true));

            assertTrue(controller.isRenameItemEnabled(treeNodeMock));
            assertTrue(controller.getResourceReadOnlyCounter() == 1);

            verify(treeNodeMock, xsdRootMock);

            // when the treNode.isReadOnly is true
            reset(treeNodeMock);

            expect(treeNodeMock.isReadOnly()).andReturn(Boolean.valueOf(true));
            replay(treeNodeMock);

            controller.setResourceReadOnlyCounter(0);
            controller.setReadOnly(false);

            controller.setPartOfEditedDocCounter(0);
            controller.setPartOfDocumentMatch(namespacedObjectMock);

            assertFalse(controller.isRenameItemEnabled(treeNodeMock));
            assertTrue(controller.getResourceReadOnlyCounter() == 1);

            verify(treeNodeMock);
        }
    }

    /*
     * Test method for {@link
     * org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController
     * #isAddElementEnabled
     * (org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.IDataTypesTreeNode)}
     * 
     * TEST COVERED BY ActionsSelectionTest
     * 
     * @SuppressWarnings("boxing")
     * 
     * @Test public final void testIsAddElementEnabled() {
     * TestDataTypesFormPageController controller = new
     * TestDataTypesFormPageController(createMock(IModelRoot.class), true);
     * 
     * assertFalse(controller.isAddElementEnabled(null));
     * 
     * // when the isReadOnly() method returns true IDataTypesTreeNode
     * dtNodeMock = createMock(IDataTypesTreeNode.class);
     * expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(true));
     * replay(dtNodeMock);
     * assertFalse(controller.isAddElementEnabled(dtNodeMock));
     * verify(dtNodeMock);
     * 
     * // when the DTNode is not one of the allegeable for element addition
     * reset(dtNodeMock);
     * expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false));
     * IModelObject modelObjectMock = createMock(IModelObject.class);
     * expect(dtNodeMock.getModelObject()).andReturn(modelObjectMock);
     * replay(dtNodeMock); controller.setPartOfDocumentMatch(modelObjectMock);
     * controller.setPartOfEdittedDocument(Boolean.valueOf(true));
     * assertFalse(controller.isAddElementEnabled(dtNodeMock));
     * verify(dtNodeMock);
     * 
     * // when the tree node is of allegable type List<Class<? extends
     * IDataTypesTreeNode>> allegableNodes = new ArrayList<Class<? extends
     * IDataTypesTreeNode>>(); allegableNodes.add(IStructureTypeNode.class);
     * allegableNodes.add(INamespaceNode.class);
     * allegableNodes.add(IElementNode.class); for (Class<? extends
     * IDataTypesTreeNode> type : allegableNodes) { dtNodeMock =
     * createMock(type);
     * expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf
     * (false)).times(2); modelObjectMock = createMock(IModelObject.class);
     * expect(dtNodeMock.getModelObject()).andReturn(modelObjectMock).times(2);
     * replay(dtNodeMock);
     * 
     * controller.setReadOnly(true);
     * 
     * controller.setResourceReadOnlyCounter(0);
     * controller.setPartOfEdittedDocument(Boolean.valueOf(true));
     * controller.setPartOfDocumentMatch(modelObjectMock);
     * assertFalse(controller.isAddElementEnabled(dtNodeMock));
     * assertTrue(controller.getResourceReadOnlyCounter() == 1);
     * controller.setReadOnly(false);
     * assertTrue(controller.isAddElementEnabled(dtNodeMock));
     * assertTrue(controller.getResourceReadOnlyCounter() == 2);
     * 
     * verify(dtNodeMock); }
     * 
     * // when the model object is an element and when it is an attribute
     * dtNodeMock = createMock(IElementNode.class); IElement elementMock =
     * createMock(IElement.class);
     * 
     * expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false));
     * expect(dtNodeMock.getModelObject()).andReturn(elementMock);
     * 
     * expect(elementMock.getType()).andReturn(createMock(IType.class));
     * expect(elementMock.isAttribute()).andReturn(Boolean.valueOf(true));
     * 
     * replay(dtNodeMock, elementMock); // prepare the test controller
     * controller.setReadOnly(false);
     * controller.setPartOfDocumentMatch(elementMock);
     * controller.setPartOfEdittedDocument(Boolean.valueOf(true)); // run the
     * test controller.setResourceReadOnlyCounter(0);
     * assertFalse(controller.isAddElementEnabled(dtNodeMock));
     * assertTrue(controller.getResourceReadOnlyCounter() == 1);
     * 
     * verify(dtNodeMock, elementMock);
     * 
     * // when type of the element is null reset(dtNodeMock, elementMock);
     * expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false));
     * expect(dtNodeMock.getModelObject()).andReturn(elementMock);
     * 
     * expect(elementMock.getType()).andReturn(null);
     * expect(elementMock.isAttribute()).andReturn(Boolean.valueOf(false));
     * 
     * replay(dtNodeMock, elementMock);
     * 
     * controller.setResourceReadOnlyCounter(0);
     * assertFalse(controller.isAddElementEnabled(dtNodeMock));
     * assertTrue(controller.getResourceReadOnlyCounter() == 1);
     * 
     * verify(dtNodeMock, elementMock);
     * 
     * // when type of the element is not null, but is not anonymous
     * reset(dtNodeMock, elementMock);
     * expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false));
     * expect(dtNodeMock.getModelObject()).andReturn(elementMock);
     * 
     * IType typeMock = createMock(IType.class);
     * expect(elementMock.getType()).andReturn(typeMock);
     * expect(elementMock.isAttribute()).andReturn(Boolean.valueOf(false));
     * expect(typeMock.isAnonymous()).andReturn(Boolean.valueOf(false));
     * 
     * replay(dtNodeMock, elementMock, typeMock);
     * 
     * controller.setResourceReadOnlyCounter(0);
     * assertFalse(controller.isAddElementEnabled(dtNodeMock));
     * assertTrue(controller.getResourceReadOnlyCounter() == 1);
     * 
     * verify(dtNodeMock, elementMock, typeMock);
     * 
     * // when the type is anonymous, but element is simple type
     * reset(dtNodeMock, elementMock);
     * expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false));
     * expect(dtNodeMock.getModelObject()).andReturn(elementMock);
     * 
     * typeMock = createMock(ISimpleType.class);
     * expect(elementMock.getType()).andReturn(typeMock);
     * expect(elementMock.isAttribute()).andReturn(Boolean.valueOf(false));
     * expect(typeMock.isAnonymous()).andReturn(Boolean.valueOf(true)).times(2);
     * 
     * replay(dtNodeMock, elementMock, typeMock);
     * 
     * controller.setResourceReadOnlyCounter(0);
     * assertFalse(controller.isAddElementEnabled(dtNodeMock));
     * assertTrue(controller.getResourceReadOnlyCounter() == 1);
     * 
     * verify(dtNodeMock, elementMock, typeMock);
     * 
     * // when the type is anonymous, but element is simple type
     * reset(dtNodeMock, elementMock);
     * expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false));
     * expect(dtNodeMock.getModelObject()).andReturn(elementMock);
     * 
     * typeMock = createMock(IStructureType.class);
     * expect(elementMock.getType()).andReturn(typeMock);
     * expect(elementMock.isAttribute()).andReturn(Boolean.valueOf(false));
     * expect(typeMock.isAnonymous()).andReturn(Boolean.valueOf(true)).times(2);
     * 
     * replay(dtNodeMock, elementMock, typeMock);
     * 
     * controller.setResourceReadOnlyCounter(0);
     * assertTrue(controller.isAddElementEnabled(dtNodeMock));
     * assertTrue(controller.getResourceReadOnlyCounter() == 1);
     * 
     * verify(dtNodeMock, elementMock, typeMock); }
     */

    /**
     * Test method for
     * {@link org.eclipse.wst.sse.sieditor.ui.v2.dt.DataTypesFormPageController#isAddSimpleTypeEnabled(org.eclipse.wst.sse.sieditor.ui.v2.dt.nodes.IDataTypesTreeNode)}
     * .
     */
    @SuppressWarnings("boxing")
    @Test
    public final void testIsAddTypeEnabled() {
        testIsAddTypeEnabledStandaloneXSDEditor();
        // when the model object does not have a parent ISchema
        final IDataTypesTreeNode dtNodeMock = createMock(IDataTypesTreeNode.class);
        final IModelObject modelObjectMock = createMock(IModelObject.class);
        expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false)).anyTimes();
        expect(dtNodeMock.getCategories()).andReturn(0).anyTimes();
        expect(dtNodeMock.getModelObject()).andReturn(null);

        replay(dtNodeMock, modelObjectMock);
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(null, false);

        assertTrue(controller.isAddTypeEnabled(dtNodeMock));
        verify(dtNodeMock, modelObjectMock);

        // when the model object has a parent schema but the node is read only
        reset(dtNodeMock, modelObjectMock);
        expect(dtNodeMock.getModelObject()).andReturn(modelObjectMock);
        expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(true));
        expect(dtNodeMock.getCategories()).andReturn(0).anyTimes();
        replay(dtNodeMock, modelObjectMock);

        assertFalse(controller.isAddTypeEnabled(dtNodeMock));

        verify(dtNodeMock, modelObjectMock);
        // when the tree node is not read only but isEditAlowed() is false
        reset(dtNodeMock, modelObjectMock);
        expect(dtNodeMock.getModelObject()).andReturn(modelObjectMock);
        expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false));
        expect(dtNodeMock.getCategories()).andReturn(0).anyTimes();
        replay(dtNodeMock, modelObjectMock);

        controller.setReadOnly(true);
        controller.setResourceReadOnlyCounter(0);
        assertFalse(controller.isAddTypeEnabled(dtNodeMock));
        assertTrue(controller.getResourceReadOnlyCounter() == 1);

        verify(dtNodeMock, modelObjectMock);

        // when the tree node does not belong to this document
        reset(dtNodeMock, modelObjectMock);
        expect(dtNodeMock.getModelObject()).andReturn(modelObjectMock).anyTimes();
        expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(false)).anyTimes();
        expect(dtNodeMock.getCategories()).andReturn(0).anyTimes();

        replay(dtNodeMock, modelObjectMock);

        controller.setReadOnly(false);
        controller.setResourceReadOnlyCounter(0);
        assertTrue(controller.isAddTypeEnabled(dtNodeMock));
        assertTrue(controller.getResourceReadOnlyCounter() == 1);
        verify(dtNodeMock, modelObjectMock);
    }

    @Test
    public void isAddTypeEnabledOnReferencedElement() {
        final IDataTypesTreeNode dtNodeMock = createMock(IDataTypesTreeNode.class);
        final IModelObject modelObjectMock = createMock(IModelObject.class);
        expect(dtNodeMock.isReadOnly()).andReturn(Boolean.valueOf(true)).anyTimes();
        expect(dtNodeMock.getCategories()).andReturn(ITreeNode.CATEGORY_REFERENCE).anyTimes();
        expect(dtNodeMock.getModelObject()).andReturn(null);

        replay(dtNodeMock, modelObjectMock);
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(null, false);

        assertTrue(controller.isAddTypeEnabled(dtNodeMock));
    }

    private void testIsAddTypeEnabledStandaloneXSDEditor() {
        TestDataTypesFormPageController controller = new TestDataTypesFormPageController(null, false);

        assertFalse(controller.isAddTypeEnabled(null));

        controller = new TestDataTypesFormPageController(createMock(IModelRoot.class), false);
        assertFalse(controller.isAddTypeEnabled(null));

        final IXSDModelRoot xsdRootMock = createMock(IXSDModelRoot.class);

        expect(xsdRootMock.getSchema()).andReturn(null);
        replay(xsdRootMock);

        controller = new TestDataTypesFormPageController(xsdRootMock, false);

        assertFalse(controller.isAddTypeEnabled(null));

        verify(xsdRootMock);

        reset(xsdRootMock);
        final ISchema schemaMock = createMock(ISchema.class);
        expect(xsdRootMock.getSchema()).andReturn(schemaMock);
        replay(xsdRootMock);

        controller.setReadOnly(true);
        controller.setResourceReadOnlyCounter(0);
        assertFalse(controller.isAddTypeEnabled(null));
        assertTrue(controller.getResourceReadOnlyCounter() == 1);

        verify(xsdRootMock);

        reset(xsdRootMock, schemaMock);
        expect(xsdRootMock.getSchema()).andReturn(schemaMock).times(2);
        replay(xsdRootMock);

        controller.setReadOnly(false);
        controller.setResourceReadOnlyCounter(0);
        assertTrue(controller.isAddTypeEnabled(null));

        assertTrue(controller.isAddTypeEnabled(null));
        assertTrue(controller.getResourceReadOnlyCounter() == 2);
        verify(xsdRootMock);
    }

    @Test
    public void isMakeGlobalEnabled() {
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(null, false);

        assertFalse(controller.isConvertToGlobalTypeEnabled(null));
        testStructureType_MakeGlobalEnablement(controller);
        testAnonymousElement_MakeGlobalEnablement_NoChildren(controller);
        testAnonymousElement_MakeGlobalEnablement_WithChildren(controller);
        testGlobalElement_MakeGlobalEnablement(controller);
        testReadonlyGlobalElement_MakeGlobalEnablement(controller);
    }

    // =========================================================
    // make type global helpers
    // =========================================================

    private void testStructureType_MakeGlobalEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType structureType = createMock(IStructureType.class);
        expect(structureType.isElement()).andReturn(false);
        final IDataTypesTreeNode structureTypeTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(structureTypeTreeNodeMock.getModelObject()).andReturn(structureType).anyTimes();
        expect(structureTypeTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        replay(structureType, structureTypeTreeNodeMock);
        assertFalse(controller.isConvertToGlobalTypeEnabled(structureTypeTreeNodeMock));
    }

    private void testAnonymousElement_MakeGlobalEnablement_NoChildren(final TestDataTypesFormPageController controller) {
        final IStructureType anonymousElement = createMock(IStructureType.class);
        expect(anonymousElement.isElement()).andReturn(true);
        expect(anonymousElement.getAllElements()).andReturn(new HashSet<IElement>());
        expect(anonymousElement.isAnonymous()).andReturn(true);
        final IDataTypesTreeNode elementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(elementTreeNodeMock.getModelObject()).andReturn(anonymousElement).anyTimes();
        expect(elementTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        replay(anonymousElement, elementTreeNodeMock);
        assertFalse(controller.isConvertToGlobalTypeEnabled(elementTreeNodeMock));
    }

    private void testAnonymousElement_MakeGlobalEnablement_WithChildren(final TestDataTypesFormPageController controller) {
        final IStructureType anonymousElement = createMock(IStructureType.class);
        expect(anonymousElement.isElement()).andReturn(true);
        final Set<IElement> set = new HashSet<IElement>();
        final IElement element = createNiceMock(IElement.class);
        set.add(element);
        expect(anonymousElement.getAllElements()).andReturn(set);
        expect(anonymousElement.isAnonymous()).andReturn(true);
        final IDataTypesTreeNode elementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(elementTreeNodeMock.getModelObject()).andReturn(anonymousElement).anyTimes();
        expect(elementTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        replay(anonymousElement, elementTreeNodeMock);
        assertTrue(controller.isConvertToGlobalTypeEnabled(elementTreeNodeMock));
    }

    private void testGlobalElement_MakeGlobalEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType globalElement = createMock(IStructureType.class);
        expect(globalElement.isElement()).andReturn(true);
        expect(globalElement.isAnonymous()).andReturn(false);
        final IDataTypesTreeNode globalElementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(globalElementTreeNodeMock.getModelObject()).andReturn(globalElement).anyTimes();
        expect(globalElementTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        replay(globalElement, globalElementTreeNodeMock);
        assertFalse(controller.isConvertToGlobalTypeEnabled(globalElementTreeNodeMock));
    }

    private void testReadonlyGlobalElement_MakeGlobalEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType readOnlyAnonymous = createMock(IStructureType.class);
        expect(readOnlyAnonymous.isElement()).andReturn(true);
        expect(readOnlyAnonymous.isAnonymous()).andReturn(false);
        final IDataTypesTreeNode readonlyAnonymousElementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(readonlyAnonymousElementTreeNodeMock.getModelObject()).andReturn(readOnlyAnonymous).anyTimes();
        expect(readonlyAnonymousElementTreeNodeMock.isReadOnly()).andReturn(true).anyTimes();
        replay(readOnlyAnonymous, readonlyAnonymousElementTreeNodeMock);
        assertFalse(controller.isConvertToGlobalTypeEnabled(readonlyAnonymousElementTreeNodeMock));
    }

    // =========================================================
    // end of make type global helpers
    // =========================================================

    @Test
    public void isMakeAnonymousEnabled() {
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(null, false);

        assertFalse(controller.isConvertToGlobalTypeEnabled(null));
        testStructureType_MakeAnonymousEnablement(controller);
        testAnonymousElement_MakeAnonymousEnablement(controller);
        testNonAnonymousElement_MakeAnonymousEnablement(controller);
        testReadonlyElement_MakeAnonymousEnablement(controller);
    }

    // =========================================================
    // make anonymous helpers
    // =========================================================

    private void testStructureType_MakeAnonymousEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType structureType = createMock(IStructureType.class);
        expect(structureType.isElement()).andReturn(false);
        final IDataTypesTreeNode structureTypeTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(structureTypeTreeNodeMock.getModelObject()).andReturn(structureType).anyTimes();
        expect(structureTypeTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        replay(structureType, structureTypeTreeNodeMock);
        assertFalse(controller.isConvertToAnonymousTypeEnabled(structureTypeTreeNodeMock));
    }

    private void testAnonymousElement_MakeAnonymousEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType anonymousElement = createMock(IStructureType.class);
        expect(anonymousElement.isElement()).andReturn(true);
        expect(anonymousElement.isAnonymous()).andReturn(true);
        final IDataTypesTreeNode elementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(elementTreeNodeMock.getModelObject()).andReturn(anonymousElement).anyTimes();
        expect(elementTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        replay(anonymousElement, elementTreeNodeMock);
        assertFalse(controller.isConvertToAnonymousTypeEnabled(elementTreeNodeMock));
    }

    private void testNonAnonymousElement_MakeAnonymousEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType globalTypeElement = createMock(IStructureType.class);
        expect(globalTypeElement.isElement()).andReturn(true);
        expect(globalTypeElement.isAnonymous()).andReturn(false);
        final IDataTypesTreeNode globalTypeElementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(globalTypeElementTreeNodeMock.getModelObject()).andReturn(globalTypeElement).anyTimes();
        expect(globalTypeElementTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        replay(globalTypeElement, globalTypeElementTreeNodeMock);
        assertTrue(controller.isConvertToAnonymousTypeEnabled(globalTypeElementTreeNodeMock));
    }

    private void testReadonlyElement_MakeAnonymousEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType readonlyGlobalTypeElement = createMock(IStructureType.class);
        expect(readonlyGlobalTypeElement.isElement()).andReturn(true);
        expect(readonlyGlobalTypeElement.isAnonymous()).andReturn(false);
        final IDataTypesTreeNode readlonlyGlobalTypeElementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(readlonlyGlobalTypeElementTreeNodeMock.getModelObject()).andReturn(readonlyGlobalTypeElement).anyTimes();
        expect(readlonlyGlobalTypeElementTreeNodeMock.isReadOnly()).andReturn(true).anyTimes();
        replay(readonlyGlobalTypeElement, readlonlyGlobalTypeElementTreeNodeMock);
        assertFalse(controller.isConvertToAnonymousTypeEnabled(readlonlyGlobalTypeElementTreeNodeMock));
    }

    // =========================================================
    // end of make anonymous helpers
    // =========================================================

    // =========================================================
    // inline structure type
    // =========================================================

    @Test
    public void isInlineStructureTypeEnabled() {
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(null, false);

        assertFalse(controller.isConvertToAnonymousTypeWithTypeContentsEnabled(null));
        testStructureType_InlineStructureEnablement(controller);
        testAnonymousElement_InlineStructureEnablement(controller);
        testNonAnonymousElement_WithSimpleType_InlineStructureEnablement(controller);
        testNonAnonymousElement_WithStructureType_InlineStructureEnablement(controller);
        testReadonlyElement_InlineStructureEnablement(controller);
    }

    // =========================================================
    // inline structure helpers
    // =========================================================

    private void testStructureType_InlineStructureEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType structureType = createMock(IStructureType.class);
        expect(structureType.isElement()).andReturn(false);
        final IDataTypesTreeNode structureTypeTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(structureTypeTreeNodeMock.getModelObject()).andReturn(structureType).anyTimes();
        expect(structureTypeTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        replay(structureType, structureTypeTreeNodeMock);
        assertFalse(controller.isConvertToAnonymousTypeWithTypeContentsEnabled(structureTypeTreeNodeMock));
    }

    private void testAnonymousElement_InlineStructureEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType anonymousElement = createMock(IStructureType.class);
        expect(anonymousElement.isElement()).andReturn(true);
        expect(anonymousElement.isAnonymous()).andReturn(true);
        final IDataTypesTreeNode elementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(elementTreeNodeMock.getModelObject()).andReturn(anonymousElement).anyTimes();
        expect(elementTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        replay(anonymousElement, elementTreeNodeMock);
        assertFalse(controller.isConvertToAnonymousTypeWithTypeContentsEnabled(elementTreeNodeMock));
    }

    private void testNonAnonymousElement_WithSimpleType_InlineStructureEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType globalTypeElement = createMock(IStructureType.class);
        expect(globalTypeElement.isElement()).andReturn(true);
        expect(globalTypeElement.isAnonymous()).andReturn(false);
        expect(globalTypeElement.getType()).andReturn(Schema.getDefaultSimpleType());
        final IDataTypesTreeNode globalTypeElementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(globalTypeElementTreeNodeMock.getModelObject()).andReturn(globalTypeElement).anyTimes();
        expect(globalTypeElementTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        replay(globalTypeElement, globalTypeElementTreeNodeMock);
        assertFalse(controller.isConvertToAnonymousTypeWithTypeContentsEnabled(globalTypeElementTreeNodeMock));
    }

    private void testNonAnonymousElement_WithStructureType_InlineStructureEnablement(
            final TestDataTypesFormPageController controller) {
        final XSDComplexTypeDefinitionImpl complexType = new XSDComplexTypeDefinitionImpl() {
            @Override
            public XSDTypeDefinition getBaseType() {
                return new XSDSimpleTypeDefinitionImpl() {
                    @Override
                    public String getName() {
                        return "anyType";
                    }
                };
            }
        };
        final IType type = createMock(IType.class);
        expect(type.getComponent()).andReturn(complexType).anyTimes();

        final IStructureType globalTypeElement = createMock(IStructureType.class);
        expect(globalTypeElement.isElement()).andReturn(true);
        expect(globalTypeElement.isAnonymous()).andReturn(false);
        final IDataTypesTreeNode globalTypeElementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(globalTypeElementTreeNodeMock.getModelObject()).andReturn(globalTypeElement).anyTimes();
        expect(globalTypeElementTreeNodeMock.isReadOnly()).andReturn(false).anyTimes();
        expect(globalTypeElement.getType()).andReturn(type).anyTimes();
        replay(globalTypeElement, globalTypeElementTreeNodeMock, type);
        assertTrue(controller.isConvertToAnonymousTypeWithTypeContentsEnabled(globalTypeElementTreeNodeMock));
    }

    private void testReadonlyElement_InlineStructureEnablement(final TestDataTypesFormPageController controller) {
        final IStructureType readonlyGlobalTypeElement = createMock(IStructureType.class);
        expect(readonlyGlobalTypeElement.isElement()).andReturn(true);
        expect(readonlyGlobalTypeElement.isAnonymous()).andReturn(false);
        final IDataTypesTreeNode readlonlyGlobalTypeElementTreeNodeMock = createMock(IDataTypesTreeNode.class);
        expect(readlonlyGlobalTypeElementTreeNodeMock.getModelObject()).andReturn(readonlyGlobalTypeElement).anyTimes();
        expect(readlonlyGlobalTypeElementTreeNodeMock.isReadOnly()).andReturn(true).anyTimes();
        replay(readonlyGlobalTypeElement, readlonlyGlobalTypeElementTreeNodeMock);
        assertFalse(controller.isConvertToAnonymousTypeWithTypeContentsEnabled(readlonlyGlobalTypeElementTreeNodeMock));
    }

    // =========================================================
    // end of inline structure helpers
    // =========================================================

    @Test
    public void testIsCopyEnabled() {
        final IModelRoot modelRoot = createNiceMock(IModelRoot.class);
        replay(modelRoot);

        final IType type = createMock(IType.class);
        replay(type);

        final IDataTypesTreeNode selectedNode = createMock(IDataTypesTreeNode.class);
        expect(selectedNode.getModelObject()).andReturn(type);
        replay(selectedNode);

        final DataTypesFormPageController controller = new DataTypesFormPageController(modelRoot, true);

        assertTrue(controller.isCopyEnabled(selectedNode));
        assertFalse(controller.isCopyEnabled(null));

    }

    @Test
    public void handleMakeAnonymous_AddChildWithOldType() {
        testMakeAnonymous(false);
    }

    private void testMakeAnonymous(final boolean addChild) {
        final ITreeNode elementNode = createMock(ITreeNode.class);
        final IStructureType element = createMock(IStructureType.class);

        final IXSDModelRoot modelRoot = createNiceMock(IXSDModelRoot.class);
        final IEnvironment env = createNiceMock(IEnvironment.class);

        expect(elementNode.getModelObject()).andReturn(element).anyTimes();
        expect(element.getModelRoot()).andReturn(modelRoot).anyTimes();
        expect(element.getName()).andReturn("").anyTimes();
        expect(modelRoot.getEnv()).andReturn(env);

        replay(modelRoot, elementNode, element);

        final boolean[] executed = { false };
        final DataTypesFormPageController controller = new DataTypesFormPageController(modelRoot, false) {
            @Override
            protected void executeSetElementAnonymousCommand(final String elementName, final boolean anonymous,
                    final AbstractNotificationOperation setAnonymousCommand, final String dialogTitle) {
                assertTrue(setAnonymousCommand instanceof MakeGlobalTypeAnonymousCommand);
                final MakeGlobalTypeAnonymousCommand command = (MakeGlobalTypeAnonymousCommand) setAnonymousCommand;
                assertSame(modelRoot, command.getModelRoot());
                assertSame(element, command.getStructureType());
                assertTrue(command.isAddChild() == addChild);
                executed[0] = true;
            }

            @Override
            protected ISchema getElementSchema(final IElement element) {
                return null;
            }
        };

        controller.handleConvertToAnonymousTypeAction(elementNode);
        assertTrue(executed[0]);
    }

    @Test
    public void handleMakeGlobal() {
        final ITreeNode elementNode = createMock(ITreeNode.class);
        final IStructureType element = createMock(IStructureType.class);

        final IXSDModelRoot modelRoot = createNiceMock(IXSDModelRoot.class);
        final IEnvironment env = createNiceMock(IEnvironment.class);

        expect(elementNode.getModelObject()).andReturn(element).anyTimes();
        expect(element.getModelRoot()).andReturn(modelRoot).anyTimes();
        expect(element.getName()).andReturn("").anyTimes();
        expect(modelRoot.getEnv()).andReturn(env);

        replay(modelRoot, element, elementNode);

        final boolean[] executed = { false };
        final DataTypesFormPageController controller = new DataTypesFormPageController(modelRoot, false) {
            @Override
            protected void executeSetElementAnonymousCommand(final String elementName, final boolean anonymous,
                    final AbstractNotificationOperation setAnonymousCommand, final String dialogTitle) {
                assertTrue(setAnonymousCommand instanceof MakeAnonymousTypeGlobalCommand);
                final MakeAnonymousTypeGlobalCommand command = (MakeAnonymousTypeGlobalCommand) setAnonymousCommand;
                assertSame(modelRoot, command.getModelRoot());
                assertSame(element, command.getStructureType());
                executed[0] = true;
            }

            @Override
            protected ISchema getElementSchema(final IElement element) {
                return null;
            }
        };

        controller.handleConvertToGlobalAction(elementNode);
        assertTrue(executed[0]);
    }

    @Test
    public void handleInlineStructureType() {
        final ITreeNode elementNode = createMock(ITreeNode.class);
        final IStructureType element = createMock(IStructureType.class);

        final IXSDModelRoot modelRoot = createNiceMock(IXSDModelRoot.class);
        final IEnvironment env = createNiceMock(IEnvironment.class);

        expect(elementNode.getModelObject()).andReturn(element).anyTimes();
        expect(element.getModelRoot()).andReturn(modelRoot).anyTimes();
        expect(element.getName()).andReturn("").anyTimes();
        expect(modelRoot.getEnv()).andReturn(env);

        replay(modelRoot, element, elementNode);

        final boolean[] executed = { false, false };
        final DataTypesFormPageController controller = new DataTypesFormPageController(modelRoot, false) {
            @Override
            protected IStatus executeCommand(final AbstractNotificationOperation inlineCommand) {
                assertTrue(inlineCommand instanceof InlineStructureTypeContentsCommand);
                final InlineStructureTypeContentsCommand command = (InlineStructureTypeContentsCommand) inlineCommand;
                assertSame(modelRoot, command.getModelRoot());
                assertSame(element, command.getStructureType());
                executed[0] = true;
                return Status.OK_STATUS;
            }

            @Override
            protected void fireTreeNodeExpandEvent(final IModelObject modelObject) {
                executed[1] = true;
                assertSame(element, modelObject);
            }

            @Override
            protected ISchema getElementSchema(final IElement element) {
                return null;
            }
        };

        controller.handleConvertToAnonymousTypeWithTypeContentsAction(elementNode);
        assertTrue(executed[0]);
        assertTrue(executed[1]);
    }

    // =========================================================
    // extract namespace
    // =========================================================

    @Test
    public void isExtractNamespaceEnabled() {
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(null, false);

        assertFalse(controller.isExtractNamespaceEnabled(null));
        testReadonlySchema(controller);
        testEdittableSchema(controller);
    }

    private void testReadonlySchema(final TestDataTypesFormPageController controller) {
        final IDataTypesTreeNode node = createMock(IDataTypesTreeNode.class);
        final ISchema schema = createNiceMock(ISchema.class);

        expect(node.isReadOnly()).andReturn(true);
        expect(node.getModelObject()).andReturn(schema);

        replay(node);

        assertFalse(controller.isExtractNamespaceEnabled(node));
    }

    private void testEdittableSchema(final TestDataTypesFormPageController controller) {
        final IDataTypesTreeNode node = createMock(IDataTypesTreeNode.class);
        final ISchema schema = createNiceMock(ISchema.class);

        expect(node.isReadOnly()).andReturn(false);
        expect(node.getModelObject()).andReturn(schema);

        replay(node);

        assertTrue(controller.isExtractNamespaceEnabled(node));
    }

    @Test
    public void handleExtractNamespace() {
        final IDataTypesTreeNode nodeMock = createMock(IDataTypesTreeNode.class);

        final boolean[] called = { false, false };
        final ExtractNamespaceWizard[] extractWizard = { null };
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(null, false) {

            @Override
            protected IStatus initWizard(final ITreeNode node, final ExtractNamespaceWizard wizard) {
                assertFalse("open wizard called before init", called[1]);
                called[0] = true;
                assertSame(nodeMock, node);
                extractWizard[0] = wizard;
                return Status.OK_STATUS;
            }

            @Override
            protected void openWizardDialog(final WizardDialog dialog) {
                assertTrue("init was not called before open", called[0]);
                called[1] = true;
                assertNotNull(extractWizard[0].getWizardDialog());
            }
        };
        controller.handleExtractNamespace(nodeMock);

        assertTrue("init wizard was not called", called[0]);
        assertTrue("open wizard dialog was not called", called[1]);
    }

    // =========================================================
    // inline namespace
    // =========================================================

    @Test
    public void isMakeAnInlineNamespaceEnabled() {
        final TestDataTypesFormPageController controller = new TestDataTypesFormPageController(null, false);

        assertFalse(controller.isMakeAnInlineNamespaceEnabled(null));
        testInlineNonImportedSchema(controller);
        testInlineImportedSchema(controller);
    }

    private void testInlineNonImportedSchema(final TestDataTypesFormPageController controller) {
        final IDataTypesTreeNode node = createMock(IDataTypesTreeNode.class);
        final ISchema schema = createNiceMock(ISchema.class);

        expect(node.getModelObject()).andReturn(schema).anyTimes();
        expect(node.getCategories()).andReturn(0);

        replay(node);

        assertFalse(controller.isMakeAnInlineNamespaceEnabled(node));
    }

    private void testInlineImportedSchema(final TestDataTypesFormPageController controller) {
        final IDataTypesTreeNode node = createMock(IDataTypesTreeNode.class);
        final ISchema schema = createMock(ISchema.class);
        final IWsdlModelRoot wsdlModelRoot = createMock(IWsdlModelRoot.class);

        expect(schema.getModelRoot()).andReturn(wsdlModelRoot);
        expect(wsdlModelRoot.getRoot()).andReturn(wsdlModelRoot);
        expect(node.getModelObject()).andReturn(schema).anyTimes();
        expect(node.getCategories()).andReturn(ITreeNode.CATEGORY_IMPORTED);

        replay(node, schema, wsdlModelRoot);

        assertTrue(controller.isMakeAnInlineNamespaceEnabled(node));
    }

    @Test
    public void handleInlineNamespace() {
        final ITreeNode schemaNode = createMock(ITreeNode.class);
        final ISchema schema = createMock(ISchema.class);

        final IWsdlModelRoot modelRoot = createMock(IWsdlModelRoot.class);
        final IEnvironment env = createNiceMock(IEnvironment.class);

        expect(schemaNode.getModelObject()).andReturn(schema).anyTimes();
        expect(schema.getModelRoot()).andReturn(modelRoot).anyTimes();
        expect(modelRoot.getRoot()).andReturn(modelRoot);
        expect(modelRoot.getEnv()).andReturn(env);

        replay(modelRoot, schema, schemaNode);

        final boolean[] executed = { false, false };
        final DataTypesFormPageController controller = new DataTypesFormPageController(modelRoot, false) {
            @Override
            protected IStatus executeCommand(final AbstractNotificationOperation inlineCommand) {
                assertTrue(inlineCommand instanceof InlineNamespaceCompositeCommand);
                final InlineNamespaceCompositeCommand command = (InlineNamespaceCompositeCommand) inlineCommand;
                assertSame(modelRoot, command.getModelRoot());
                assertSame(schema, command.getSourceSchema());
                executed[0] = true;
                return Status.OK_STATUS;
            }

            @Override
            protected void fireTreeNodeExpandEvent(final IModelObject modelObject) {
                executed[1] = true;
                assertNull(modelObject);
            }

        };

        controller.handleMakeAnInlineNamespace(schemaNode);
        assertTrue(executed[0]);
        assertTrue(executed[1]);
    }

}