/*******************************************************************************
 * Copyright (c) 2010, 2014 THALES GLOBAL SERVICES.
 * 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:
 *    Obeo - initial API and implementation
 *******************************************************************************/
package org.eclipse.sirius.tests.swtbot;

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

import org.eclipse.sirius.diagram.ui.edit.api.part.AbstractDiagramEdgeEditPart;
import org.eclipse.sirius.tests.support.api.TestsUtil;
import org.eclipse.sirius.tests.swtbot.sequence.condition.CheckTreeItemFontFormat;
import org.eclipse.sirius.tests.swtbot.support.api.condition.OperationDoneCondition;
import org.eclipse.sirius.tests.swtbot.support.api.condition.TreeItemExpanded;
import org.eclipse.sirius.tests.swtbot.support.api.condition.TreeItemSelected;
import org.eclipse.sirius.tests.swtbot.support.utils.SWTBotUtils;
import org.eclipse.sirius.viewpoint.FontFormat;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditPart;
import org.eclipse.swtbot.swt.finder.exceptions.WidgetNotFoundException;
import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
import org.eclipse.swtbot.swt.finder.waits.ICondition;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
import org.junit.Assert;

import com.google.common.collect.Sets;

/**
 * Tests ensuring that hide/reveal Labels located on the border of a
 * Node/Bordered Node works correctly.
 * 
 * The hide/reveal action will be tested :
 * <ul>
 * <li>From Outline, Context menu and Tabbar</li>
 * <li>By selecting the Label, the Node that contains it or the Bordered Node
 * that Contains it.</li>
 * <li>Reveal actions will only be called from Outline, please see
 * DiagramElementSelectionDialogWithLabelInBorderTest for the test of the
 * Show/Hide wizard on labels.
 * </ul>
 * 
 * @author alagarde
 */
public class HideRevealDiagramElementsLabelsTest extends AbstractHideRevealDiagramElementsLabelTest {

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * tabbar (right-click on node).
     */
    public void testHideLabelWithTabbarOnNode() {

        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(NODE_WITH_LABEL_NAME).parent();

        checkLabelIsVisible(NODE_WITH_LABEL_NAME);
        editor.select(Sets.newHashSet(editPart));
        editor.bot().toolbarButtonWithTooltip(HIDE_LABEL_TOOLTIP).click();

        checkLabelIsHidden(NODE_WITH_LABEL_NAME);

        // Step 2 : ensure that the tabbar doesn't propose user to hide label
        // anymore
        boolean hideLabelTabbarFound = true;
        editor.select(editPart);

        // Wait all UI events to ensure that the tabbar is correctly refreshed.
        SWTBotUtils.waitAllUiEvents();
        SWTBotToolbarButton button = null;
        final long oldTimeout = SWTBotPreferences.TIMEOUT;
        try {
            SWTBotPreferences.TIMEOUT = 1000;
            button = editor.bot().toolbarButtonWithTooltip(HIDE_LABEL_TOOLTIP);
        } catch (WidgetNotFoundException e) {
            hideLabelTabbarFound = false;
        } finally {
            SWTBotPreferences.TIMEOUT = oldTimeout;
            Assert.assertFalse("The tabbar shouldn't allow user to hide label of " + NODE_WITH_LABEL_NAME + " (as it is already hidden)", hideLabelTabbarFound && button.isEnabled());
        }
    }

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * tabbar (right-click on edge).
     */
    public void testHideLabelWithTabbarOnEdge() {

        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(EDGE_WITH_LABEL_NAME).parent();

        checkEdgeLabelIsVisible(EDGE_WITH_LABEL_NAME);
        editor.select(Sets.newHashSet(editPart));
        editor.bot().toolbarButtonWithTooltip(HIDE_LABEL_TOOLTIP).click();

        checkEdgeLabelIsHidden(EDGE_WITH_LABEL_NAME);

        // Step 2 : ensure that the tabbar doesn't propose user to hide label
        // anymore
        boolean hideLabelTabbarFound = true;
        editor.select(editPart);

        // Wait all UI events to ensure that the tabbar is correctly refreshed.
        SWTBotUtils.waitAllUiEvents();
        SWTBotToolbarButton button = null;
        final long oldTimeout = SWTBotPreferences.TIMEOUT;
        try {
            SWTBotPreferences.TIMEOUT = 1000;
            button = editor.bot().toolbarButtonWithTooltip(HIDE_LABEL_TOOLTIP);
        } catch (WidgetNotFoundException e) {
            hideLabelTabbarFound = false;
        } finally {
            SWTBotPreferences.TIMEOUT = oldTimeout;
            Assert.assertFalse("The tabbar shouldn't allow user to hide label of " + EDGE_WITH_LABEL_NAME + " (as it is already hidden)", hideLabelTabbarFound && button.isEnabled());
        }
    }

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * tabbar (right-click on a bordered node).
     */
    public void testHideLabelWithTabbarOnBorderedNode() {
        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(BORDERED_NODE_WITH_LABEL_NAME).parent();

        checkLabelIsVisible(BORDERED_NODE_WITH_LABEL_NAME);
        editor.select(Sets.newHashSet(editPart));
        editor.bot().toolbarButtonWithTooltip(HIDE_LABEL_TOOLTIP).click();

        checkLabelIsHidden(BORDERED_NODE_WITH_LABEL_NAME);

        // Step 2 : ensure that the tabbar doesn't propose user to hide label
        // anymore
        boolean hideLabelTabbarFound = true;
        editor.select(editPart);
        // Wait all UI events to ensure that the tabbar is correctly refreshed.
        SWTBotUtils.waitAllUiEvents();
        SWTBotToolbarButton button = null;
        final long oldTimeout = SWTBotPreferences.TIMEOUT;
        try {
            SWTBotPreferences.TIMEOUT = 1000;
            button = editor.bot().toolbarButtonWithTooltip(HIDE_LABEL_TOOLTIP);
        } catch (WidgetNotFoundException e) {
            hideLabelTabbarFound = false;
        } finally {
            SWTBotPreferences.TIMEOUT = oldTimeout;
            Assert.assertFalse("The tabbar shouldn't allow user to hide label of " + BORDERED_NODE_WITH_LABEL_NAME + " (as it is already hidden)", hideLabelTabbarFound && button.isEnabled());
        }
    }

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * tabbar (right-click on label).
     */
    public void testHideLabelWithTabbarOnLabel() {

        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(NODE_WITH_LABEL_NAME);
        SWTBotGefEditPart parentEditPart = editPart.parent();
        checkLabelIsVisible(NODE_WITH_LABEL_NAME);
        editor.select(Sets.newHashSet(editPart));
        editor.bot().toolbarButtonWithTooltip(HIDE_LABEL_TOOLTIP).click();

        checkLabelIsHidden(NODE_WITH_LABEL_NAME);

        // Step 2 : ensure that the tabbar doesn't propose user to hide label
        // anymore
        boolean hideLabelTabbarFound = true;
        editor.select(parentEditPart);
        // Wait all UI events to ensure that the tabbar is correctly refreshed.
        SWTBotUtils.waitAllUiEvents();
        SWTBotToolbarButton button = null;
        final long oldTimeout = SWTBotPreferences.TIMEOUT;
        try {
            SWTBotPreferences.TIMEOUT = 1000;
            button = editor.bot().toolbarButtonWithTooltip(HIDE_LABEL_TOOLTIP);
        } catch (WidgetNotFoundException e) {
            hideLabelTabbarFound = false;
        } finally {
            SWTBotPreferences.TIMEOUT = oldTimeout;
            Assert.assertFalse("The tabbar shouldn't allow user to hide label of " + NODE_WITH_LABEL_NAME + " (as it is already hidden)", hideLabelTabbarFound && button.isEnabled());
        }
    }

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * context menu (right-click on the Node).
     */
    public void testHideLabelWithContextMenuOnNode() {
        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(NODE_WITH_LABEL_NAME).parent();
        checkLabelIsVisible(NODE_WITH_LABEL_NAME);
        editor.select(Sets.newHashSet(editPart));
        editor.clickContextMenu(HIDE_LABEL_TOOLTIP);

        checkLabelIsHidden(NODE_WITH_LABEL_NAME);

        // Step 2 : ensure that the context menu doesn't propose user to hide
        // label anymore
        boolean hideLabelContextMenuActionFound = true;
        editor.select(editPart);
        final long oldTimeout = SWTBotPreferences.TIMEOUT;
        try {
            SWTBotPreferences.TIMEOUT = 1000;
            editor.clickContextMenu(HIDE_LABEL_TOOLTIP);
        } catch (WidgetNotFoundException e) {
            hideLabelContextMenuActionFound = false;
        } finally {
            SWTBotPreferences.TIMEOUT = oldTimeout;
            Assert.assertFalse("The context menu shouldn't allow user to hide label of " + NODE_WITH_LABEL_NAME + " (as it is already hidden)", hideLabelContextMenuActionFound);
        }
    }

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * context menu (right-click on the Edge).
     */
    public void testHideLabelWithContextMenuOnEdge() {
        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(EDGE_WITH_LABEL_NAME).parent();
        checkEdgeLabelIsVisible(EDGE_WITH_LABEL_NAME);
        editor.select(Sets.newHashSet(editPart));
        editor.clickContextMenu(HIDE_LABEL_TOOLTIP);

        checkEdgeLabelIsHidden(EDGE_WITH_LABEL_NAME);

        // Step 2 : ensure that the context menu doesn't propose user to hide
        // label anymore
        boolean hideLabelContextMenuActionFound = true;
        editor.select(editPart);
        try {
            editor.clickContextMenu(HIDE_LABEL_TOOLTIP);
        } catch (WidgetNotFoundException e) {
            hideLabelContextMenuActionFound = false;
        } finally {
            Assert.assertFalse("The context menu shouldn't allow user to hide label of " + EDGE_WITH_LABEL_NAME + " (as it is already hidden)", hideLabelContextMenuActionFound);
        }
    }

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * context menu (right-click on the Bordered Node).
     */
    public void testHideLabelWithContextMenuOnBorderedNode() {
        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(BORDERED_NODE_WITH_LABEL_NAME).parent();
        checkLabelIsVisible(BORDERED_NODE_WITH_LABEL_NAME);
        editor.select(Sets.newHashSet(editPart));
        editor.clickContextMenu(HIDE_LABEL_TOOLTIP);

        checkLabelIsHidden(BORDERED_NODE_WITH_LABEL_NAME);

        // Step 2 : ensure that the context menu doesn't propose user to hide
        // label anymore
        boolean hideLabelContextMenuActionFound = true;
        editor.select(editPart);
        try {
            editor.clickContextMenu(HIDE_LABEL_TOOLTIP);
        } catch (WidgetNotFoundException e) {
            hideLabelContextMenuActionFound = false;
        } finally {
            Assert.assertFalse("The context menu shouldn't allow user to hide label of " + BORDERED_NODE_WITH_LABEL_NAME + " (as it is already hidden)", hideLabelContextMenuActionFound);
        }
    }

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * context menu (right-click on the label).
     */
    public void testHideLabelWithContextMenuOnLabel() {
        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(NODE_WITH_LABEL_NAME);
        SWTBotGefEditPart parentEditPart = editPart.parent();
        checkLabelIsVisible(NODE_WITH_LABEL_NAME);
        editor.select(Sets.newHashSet(editPart));
        editor.clickContextMenu(HIDE_LABEL_TOOLTIP);

        checkLabelIsHidden(NODE_WITH_LABEL_NAME);

        // Step 2 : ensure that the context menu doesn't propose user to hide
        // label anymore
        boolean hideLabelContextMenuActionFound = true;
        editor.select(parentEditPart);
        try {
            editor.clickContextMenu(HIDE_LABEL_TOOLTIP);
        } catch (WidgetNotFoundException e) {
            hideLabelContextMenuActionFound = false;
        } finally {
            Assert.assertFalse("The context menu shouldn't allow user to hide label of " + NODE_WITH_LABEL_NAME + " (as it is already hidden)", hideLabelContextMenuActionFound);
        }
    }

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * the outline on Node.
     * 
     * @throws Exception
     *             if a recursive exception occurs
     */
    public void testHideAndRevealLabelWithOutlineOnNode() throws Exception {
        if (TestsUtil.shouldSkipUnreliableTests()) {
            // Can cause timeouts.
            return;
        }
        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(NODE_WITH_LABEL_NAME);
        SWTBotGefEditPart parentEditPart = editPart.parent();
        checkLabelIsVisible(NODE_WITH_LABEL_NAME);

        final SWTBotView view = getAndExpandOutlineView(true);

        // Step 1.2 : open the context menu the element to hide and select the
        // hide element action
        SWTBotTreeItem labelItem = view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).getNode(NODE_WITH_LABEL_NAME + " " + LABEL_SUFFIX_IN_OUTLINE).click();
        view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).getNode(NODE_WITH_LABEL_NAME + " " + LABEL_SUFFIX_IN_OUTLINE).select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(labelItem));
        setShownImage(labelItem);
        SWTBotTreeItem nodeItem = view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).click();
        view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(nodeItem));
        checkOutlineIsCorrectlyDecorated(labelItem, false);
        nodeItem.contextMenu(HIDE_LABEL_TOOLTIP).click();

        // Step 1.3 : ensure node is hidden
        checkLabelIsHidden(NODE_WITH_LABEL_NAME);
        checkOutlineIsCorrectlyDecorated(labelItem, true);

        // Step 2 : ensure that the outline doesn't propose user to hide
        // label anymore
        boolean outlineAllowToHideLabel = true;
        boolean outlineAllowToRevealLabel = false;

        editor.select(parentEditPart);
        SWTBotUtils.waitAllUiEvents();
        final long oldTimeout = SWTBotPreferences.TIMEOUT;
        try {
            SWTBotPreferences.TIMEOUT = 1000;
            nodeItem.click().contextMenu(HIDE_LABEL_TOOLTIP).click();
        } catch (RuntimeException e) {
            outlineAllowToHideLabel = false;
            try {
                nodeItem.click().contextMenu(REVEAL_LABEL_TOOLTIP).click();
                outlineAllowToRevealLabel = true;
            } catch (WidgetNotFoundException wnfe) {
                outlineAllowToRevealLabel = false;
            }
        } finally {
            SWTBotPreferences.TIMEOUT = oldTimeout;
            Assert.assertFalse("The context menu shouldn't allow user to hide label of " + editPart.part(), outlineAllowToHideLabel);
            Assert.assertTrue("The context menu should allow user to show label of " + editPart.part(), outlineAllowToRevealLabel);

            // Step 4 : we ensure that label has been correctly revealed
            checkLabelIsVisible(NODE_WITH_LABEL_NAME);
            checkOutlineIsCorrectlyDecorated(labelItem, false);
        }

    }

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * the outline on Edge.
     * 
     * @throws Exception
     *             if a recursive exception occurs
     */
    public void testHideAndRevealLabelWithOutlineOnEdge() throws Exception {
        if (TestsUtil.shouldSkipUnreliableTests()) {
            // Causes timeout.
            return;
        }
        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(EDGE_WITH_LABEL_NAME);
        SWTBotGefEditPart parentEditPart = editPart.parent();
        checkEdgeLabelIsVisible(EDGE_WITH_LABEL_NAME);

        final SWTBotView view = getAndExpandOutlineView(true);

        // Step 1.2 : open the context menu the element to hide and select the
        // hide element action
        SWTBotTreeItem labelItem = view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").getNode(LABEL_SUFFIX_IN_OUTLINE).click();
        view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").getNode(LABEL_SUFFIX_IN_OUTLINE).select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(labelItem));
        setShownImage(labelItem);
        SWTBotTreeItem nodeItem = view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").click();
        view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(nodeItem));
        checkOutlineIsCorrectlyDecorated(labelItem, false);
        nodeItem.contextMenu(HIDE_LABEL_TOOLTIP).click();

        // Step 1.3 : ensure node is hidden
        checkEdgeLabelIsHidden(EDGE_WITH_LABEL_NAME);
        checkOutlineIsCorrectlyDecorated(labelItem, true);

        // Step 2 : ensure that the outline doesn't propose user to hide
        // label anymore
        boolean outlineAllowToHideLabel = true;
        boolean outlineAllowToRevealLabel = false;

        editor.select(parentEditPart);
        SWTBotUtils.waitAllUiEvents();
        final long oldTimeout = SWTBotPreferences.TIMEOUT;
        try {
            SWTBotPreferences.TIMEOUT = 1000;
            nodeItem.click().contextMenu(HIDE_LABEL_TOOLTIP).click();
        } catch (RuntimeException e) {
            outlineAllowToHideLabel = false;
            try {
                nodeItem.click().contextMenu(REVEAL_LABEL_TOOLTIP).click();
                outlineAllowToRevealLabel = true;
            } catch (WidgetNotFoundException wnfe) {
                outlineAllowToRevealLabel = false;
            }
        } finally {
            SWTBotPreferences.TIMEOUT = oldTimeout;
            Assert.assertFalse("The context menu shouldn't allow user to hide label of " + editPart.part(), outlineAllowToHideLabel);
            Assert.assertTrue("The context menu should allow user to show label of " + editPart.part(), outlineAllowToRevealLabel);

            // Step 4 : we ensure that label has been correctly revealed
            checkEdgeLabelIsVisible(EDGE_WITH_LABEL_NAME);
            checkOutlineIsCorrectlyDecorated(labelItem, false);
        }

    }

    /**
     * Ensures that the Hide and Reveal Actions works correctly when called from
     * the outline on a Label.
     * 
     * @throws Exception
     *             if a recursive exception occurs
     */
    public void testHideAndRevealLabelWithOutlineOnLabel() throws Exception {
        if (TestsUtil.shouldSkipUnreliableTests()) {
            return;
        }
        // Step 1 : hide the label and check that it is correctly hidden
        SWTBotGefEditPart editPart = editor.getEditPart(NODE_WITH_LABEL_NAME);
        SWTBotGefEditPart parentEditPart = editPart.parent();
        checkLabelIsVisible(NODE_WITH_LABEL_NAME);

        // Step 1.1 : open the outline view and get its SWTBotView
        final SWTBotView view = getAndExpandOutlineView(true);

        // Step 1.2 : open the context menu the element to hide and select the
        // hide element action
        SWTBotTreeItem item = view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).getNode(NODE_WITH_LABEL_NAME + " " + LABEL_SUFFIX_IN_OUTLINE).click();
        view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).getNode(NODE_WITH_LABEL_NAME + " " + LABEL_SUFFIX_IN_OUTLINE).select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(item));
        setShownImage(item);
        checkOutlineIsCorrectlyDecorated(item, false);
        item.contextMenu(HIDE_LABEL_TOOLTIP).click();

        // Step 1.3 : ensure node is hidden
        checkLabelIsHidden(NODE_WITH_LABEL_NAME);
        checkOutlineIsCorrectlyDecorated(item, true);

        // Step 3 : ensure that the outline doesn't propose user to hide
        // label anymore
        boolean outlineAllowToHideLabel = true;
        boolean outlineAllowToRevealLabel = false;

        editor.select(parentEditPart);
        SWTBotUtils.waitAllUiEvents();
        try {
            item = view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME + LABEL_SUFFIX_IN_OUTLINE).click();
            view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME + LABEL_SUFFIX_IN_OUTLINE).select();
            SWTBotUtils.waitAllUiEvents();
            bot.waitUntil(new TreeItemSelected(item));
            item.contextMenu(HIDE_LABEL_TOOLTIP).click();
        } catch (WidgetNotFoundException e) {
            outlineAllowToHideLabel = false;
            try {
                item.contextMenu(REVEAL_LABEL_TOOLTIP).click();
                outlineAllowToRevealLabel = true;
            } catch (WidgetNotFoundException wnfe) {
                outlineAllowToRevealLabel = false;
            }
        } finally {
            Assert.assertFalse("The context menu shouldn't allow user to hide label of " + editPart.part(), outlineAllowToHideLabel);
            Assert.assertTrue("The context menu should allow user to show label of " + editPart.part(), outlineAllowToRevealLabel);

            // Step 4 : we ensure that label has been correctly revealed
            checkLabelIsVisible(NODE_WITH_LABEL_NAME);
            checkOutlineIsCorrectlyDecorated(item, false);
        }

    }

    /**
     * 
     * <ul>
     * <li>Hide a label of a node --> The label disappears</li>
     * <li>Hide the node --> The node disappears</li>
     * <li>Reveal the node --> The node appears without the label</li>
     * <li>Reveal the label of the node --> The label appears</li>
     * <li>
     * </ul>
     * 
     * @throws Exception
     *             if a reflective exception occurred
     * 
     */
    public void testRevealEdgeAfterHideLabelWithOutline() throws Exception {
        if (TestsUtil.shouldSkipUnreliableTests()) {
            return;
        }

        // Step 1 : hide the label (using Context menu) and check that it is
        // correctly hidden
        SWTBotGefEditPart labelEditPart = editor.getEditPart(EDGE_WITH_LABEL_NAME);
        SWTBotGefEditPart nodeEditPart = labelEditPart.parent();
        checkEdgeLabelIsVisible(EDGE_WITH_LABEL_NAME);

        editor.select(nodeEditPart);
        // Wait all UI events to ensure that the tabbar is correctly refreshed.
        SWTBotUtils.waitAllUiEvents();
        ICondition done = new OperationDoneCondition();
        editor.bot().toolbarButtonWithTooltip(HIDE_LABEL_TOOLTIP).click();
        bot.waitUntil(done);

        checkEdgeLabelIsHidden(EDGE_WITH_LABEL_NAME);

        // Step 2 : now we hide the node (using the context menu)
        editor.select(nodeEditPart);
        done = new OperationDoneCondition();
        editor.clickContextMenu(HIDE_ELEMENT_TOOLTIP);
        bot.waitUntil(done);
        checkEdgeIsHidden(nodeEditPart);

        // Step 3 : reveal the node (using outline)
        // The label must still be hidden
        // Step 3.1 : open the outline view and get its SWTBotView
        final SWTBotView view = getAndExpandOutlineView(false);

        // Step 3.2 : open the context menu the element to reveal and select the
        // reveal element action
        SWTBotTreeItem item = view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").click();
        view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(item));
        SWTBotUtils.clickContextMenu(item, REVEAL_ELEMENT_TOOLTIP);
        checkEdgeLabelIsHidden(EDGE_WITH_LABEL_NAME);

        // Step 4 : reveal the label (using outline)
        item = view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").click();
        view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(item));
        done = new OperationDoneCondition();
        SWTBotUtils.clickContextMenu(item, REVEAL_LABEL_TOOLTIP);
        bot.waitUntil(done);
        checkEdgeLabelIsVisible(EDGE_WITH_LABEL_NAME);
    }

    /**
     * 
     * <ul>
     * <li>Hide a label of a node --> The label disappears</li>
     * <li>Hide the node --> The node disappears</li>
     * <li>Reveal the node --> The node appears without the label</li>
     * <li>Reveal the label of the node --> The label appears</li>
     * <li>
     * </ul>
     * 
     * @throws Exception
     *             if a reflective exception occurred
     * 
     */
    public void testRevealNodeAfterHideLabelWithOutline() throws Exception {
        if (TestsUtil.shouldSkipUnreliableTests()) {
            /*
             * org.eclipse.swtbot.swt.finder.widgets.TimeoutException: Timeout
             * after: 10000 ms.: tree item with text myEnum is not selected at
             * org
             * .eclipse.swtbot.swt.finder.SWTBotFactory.waitUntil(SWTBotFactory
             * .java:407) at
             * org.eclipse.swtbot.swt.finder.SWTBotFactory.waitUntil
             * (SWTBotFactory.java:381) at
             * org.eclipse.swtbot.swt.finder.SWTBotFactory
             * .waitUntil(SWTBotFactory.java:369) at
             * org.eclipse.sirius.tests.swtbot
             * .HideRevealDiagramElementsLabelsTest
             * .testRevealNodeAfterHideLabelWithOutline
             * (HideRevealDiagramElementsLabelsTest.java:569)
             */
            return;
        }
        // Step 1 : hide the label (using Context menu) and check that it is
        // correctly hidden
        SWTBotGefEditPart labelEditPart = editor.getEditPart(NODE_WITH_LABEL_NAME);
        SWTBotGefEditPart nodeEditPart = labelEditPart.parent();
        checkLabelIsVisible(NODE_WITH_LABEL_NAME);

        editor.select(nodeEditPart);
        // Wait all UI events to ensure that the tabbar is correctly refreshed.
        SWTBotUtils.waitAllUiEvents();
        editor.bot().toolbarButtonWithTooltip(HIDE_LABEL_TOOLTIP).click();

        checkLabelIsHidden(NODE_WITH_LABEL_NAME);

        // Step 2 : now we hide the node (using the context menu)
        editor.select(nodeEditPart);
        editor.clickContextMenu(HIDE_ELEMENT_TOOLTIP);
        checkNodeIsHidden(nodeEditPart);

        // Step 3 : reveal the node (using outline)
        // The label must still be hidden
        // Step 3.1 : open the outline view and get its SWTBotView
        final SWTBotView view = getAndExpandOutlineView(false);

        // Step 3.2 : open the context menu the element to reveal and select the
        // reveal element action
        SWTBotTreeItem item = view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).click();
        view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(item));
        item.contextMenu(REVEAL_ELEMENT_TOOLTIP).click();
        checkLabelIsHidden(NODE_WITH_LABEL_NAME);
        checkNodeIsVisible(nodeEditPart);
        bot.waitUntil(new CheckTreeItemFontFormat(item, new ArrayList<FontFormat>()));

        // Step 4 : reveal the label (using outline)
        item = view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).click();
        view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).select();
        SWTBotUtils.waitAllUiEvents();
        TreeItemExpanded treeItemExpanded = new TreeItemExpanded(item, NODE_WITH_LABEL_NAME);
        item.expand();
        bot.waitUntil(treeItemExpanded);

        // Validates that the FontFormat of the TreeItem changes when the
        // visibility changes
        List<FontFormat> widgetFormat = SWTBotUtils.getWidgetFormat(item.getNode(NODE_WITH_LABEL_NAME + " label").widget);
        assertEquals(FontFormat.ITALIC, widgetFormat.get(0).getValue());
        SWTBotUtils.clickContextMenu(item, REVEAL_LABEL_TOOLTIP);

        bot.waitUntil(new CheckTreeItemFontFormat(item, new ArrayList<FontFormat>()));

        checkLabelIsVisible(NODE_WITH_LABEL_NAME);
    }

    /**
     * 
     * <ul>
     * <li>Hide a label of a node --> The label disappears</li>
     * <li>Hide the node --> The node disappears</li>
     * <li>Reveal the label of the node --> The node is still hidden</li>
     * <li>Reveal the node --> The node appears with the label</li>
     * 
     * <li>
     * </ul>
     * * @throws Exception if a reflective exception occurred
     */
    public void testRevealNodeAfterHideAndRevealLabelWithOutline() throws Exception {
        if (TestsUtil.shouldSkipUnreliableTests()) {
            return;
        }
        // Step 1 : hide the label (using Outline) and check that it is
        // correctly hidden
        SWTBotGefEditPart labelEditPart = editor.getEditPart(NODE_WITH_LABEL_NAME);
        SWTBotGefEditPart nodeEditPart = labelEditPart.parent();
        checkLabelIsVisible(NODE_WITH_LABEL_NAME);

        editor.select(nodeEditPart);
        editor.clickContextMenu(HIDE_LABEL_TOOLTIP);
        checkLabelIsHidden(NODE_WITH_LABEL_NAME);

        // Step 2 : now he hide the node (using the context menu)
        editor.select(nodeEditPart);
        editor.clickContextMenu(HIDE_ELEMENT_TOOLTIP);

        checkNodeIsHidden(nodeEditPart);

        // Step 3 : reveal the label (using outline)
        // Node must still be hidden
        // Step 3.1 : open the outline view and get its SWTBotView
        final SWTBotView view = getAndExpandOutlineView(true);

        // Step 3.2 : open the context menu the label to reveal and select the
        // reveal label action
        SWTBotTreeItem item = view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).click();
        view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(item));
        item.contextMenu(REVEAL_LABEL_TOOLTIP).click();
        checkNodeIsHidden(nodeEditPart);

        // Step 4 : reveal the node (using outline)
        // The label must now be visible
        item = view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).click();
        view.bot().tree().getTreeItem("p").getNode(NODE_WITH_LABEL_NAME).select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(item));
        item.contextMenu(REVEAL_ELEMENT_TOOLTIP).click();
        checkLabelIsVisible(NODE_WITH_LABEL_NAME);

    }

    /**
     * 
     * <ul>
     * <li>Hide a label of an edge --> The label disappears</li>
     * <li>Hide the edge --> The edge disappears</li>
     * <li>Reveal the label of the edge --> The edge is still hidden</li>
     * <li>Reveal the edge --> The edge appears with the label</li>
     * 
     * <li>
     * </ul>
     * * @throws Exception if a reflective exception occurred
     */
    public void testRevealEdgeAfterHideAndRevealLabelWithOutline() throws Exception {
        if (TestsUtil.shouldSkipUnreliableTests()) {
            return;
        }

        // Step 1 : hide the label (using the context menu) and check that it is
        // correctly hidden
        SWTBotGefEditPart edgeEditPart = editor.getEditPart(EDGE_WITH_LABEL_NAME, AbstractDiagramEdgeEditPart.class);
        checkEdgeLabelIsVisible(EDGE_WITH_LABEL_NAME);

        editor.select(edgeEditPart);
        editor.clickContextMenu(HIDE_LABEL_TOOLTIP);
        checkEdgeLabelIsHidden(EDGE_WITH_LABEL_NAME);

        // Step 2 : now we hide the edge (using the context menu)
        editor.select(edgeEditPart);
        editor.clickContextMenu(HIDE_ELEMENT_TOOLTIP);

        checkEdgeIsHidden(edgeEditPart);

        // Step 3 : reveal the label (using outline)
        // Edge must still be hidden
        // Step 3.1 : open the outline view and get its SWTBotView
        final SWTBotView view = getAndExpandOutlineView(true);

        // Step 3.2 : open the context menu the label to reveal and select the
        // reveal label action
        SWTBotTreeItem item = view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").click();
        view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(item));
        item.contextMenu(REVEAL_LABEL_TOOLTIP).click();
        checkEdgeIsHidden(edgeEditPart);

        // Step 4 : reveal the node (using outline)
        // The label must now be visible
        item = view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").click();
        view.bot().tree().getTreeItem("p").getNode(EDGE_WITH_LABEL_NAME + " : B").select();
        SWTBotUtils.waitAllUiEvents();
        bot.waitUntil(new TreeItemSelected(item));
        item.contextMenu(REVEAL_ELEMENT_TOOLTIP).click();
        checkEdgeLabelIsVisible(EDGE_WITH_LABEL_NAME);
    }
}