/******************************************************************************
 * Copyright (c) 2016, 2019 Ericsson
 *
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License 2.0 which
 * accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *******************************************************************************/

package org.eclipse.tracecompass.integration.swtbot.tests.projectexplorer;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.fail;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Set;
import java.util.function.Supplier;

import org.apache.log4j.ConsoleAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.SimpleLayout;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable;
import org.eclipse.swtbot.swt.finder.junit.SWTBotJunit4ClassRunner;
import org.eclipse.swtbot.swt.finder.results.Result;
import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
import org.eclipse.swtbot.swt.finder.waits.Conditions;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.importtrace.ImportConfirmation;
import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.importtrace.ImportTraceWizardPage;
import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomTxtTraceDefinition;
import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomXmlTraceDefinition;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTracesFolder;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.wizards.SWTBotImportWizardUtils;
import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
import org.eclipse.ui.IPageLayout;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.MethodSorters;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;

/**
 * SWTBot test for testing Project Explorer trace folders (context-menu,
 * import, etc).
 */
@RunWith(SWTBotJunit4ClassRunner.class)
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
@SuppressWarnings({"restriction", "javadoc"})
public class ProjectExplorerTracesFolderTest {

    private static final String RESOURCE_PROPERTIES = "Resource properties";

    private static final class ImportConfirmationSupplier implements Supplier<ImportConfirmation> {
        List<ImportConfirmation> fConfirmations = Lists.newArrayList(ImportConfirmation.CONTINUE);

        public ImportConfirmationSupplier(ImportConfirmation... confirmations) {
            fConfirmations = Lists.newArrayList(confirmations);
        }

        @Override
        public ImportConfirmation get() {
            return fConfirmations.isEmpty() ? null : fConfirmations.remove(0);
        }
    }

    private static final String PROP_LAST_MODIFIED_PROPERTY = "last modified";
    private static final String TEXT_EDITOR_ID = "org.eclipse.ui.DefaultTextEditor";

    private static final String GENERIC_CTF_TRACE_TYPE = "Common Trace Format : Generic CTF Trace";
    private static final String LTTNG_KERNEL_TRACE_TYPE = "Common Trace Format : Linux Kernel Trace";
    private static final String LTTNG_UST_TRACE_TYPE = "Common Trace Format : LTTng UST Trace";
    private static final String CUSTOM_TEXT_TRACE_TYPE = "Custom Text : TmfGeneric";
    private static final String CUSTOM_XML_TRACE_TYPE = "Custom XML : Custom XML Log";

    private static final @NonNull TestTraceInfo CUSTOM_TEXT_LOG = new TestTraceInfo("ExampleCustomTxt.log", CUSTOM_TEXT_TRACE_TYPE, 10, "29:52.034");
    private static final @NonNull TestTraceInfo CUSTOM_XML_LOG = new TestTraceInfo("ExampleCustomXml.xml", CUSTOM_XML_TRACE_TYPE, 6, "22:01:20");
    private static final @NonNull TestTraceInfo LTTNG_KERNEL_TRACE = new TestTraceInfo("kernel-overlap-testing", LTTNG_KERNEL_TRACE_TYPE, 1000, "04:32.650 993 664");
    private static final @NonNull TestTraceInfo SIMPLE_SERVER1_UST_TRACE = new TestTraceInfo("simple_server-thread1", LTTNG_UST_TRACE_TYPE, 1000, "04:32.650 993 664");
    private static final @NonNull TestTraceInfo SIMPLE_SERVER2_UST_TRACE = new TestTraceInfo("simple_server-thread2", LTTNG_UST_TRACE_TYPE, 1000, "04:32.650 993 664");
    private static final @NonNull TestTraceInfo UST_OVERLAP_TESTING_UST_TRACE = new TestTraceInfo("ust-overlap-testing", LTTNG_UST_TRACE_TYPE, 1000, "04:32.650 993 664");

    private static final String CLASHES_DIR_NAME = "z-clashes";
    private static final @NonNull TestTraceInfo CLASHES_CUSTOM_TEXT_LOG = new TestTraceInfo("ExampleCustomTxt.log", CLASHES_DIR_NAME + "/ExampleCustomTxt.log", CUSTOM_TEXT_TRACE_TYPE, 11, "29:52.034");
    private static final @NonNull TestTraceInfo CLASHES_CUSTOM_XML_LOG = new TestTraceInfo("ExampleCustomXml.xml", CLASHES_DIR_NAME + "/ExampleCustomXml.xml", CUSTOM_XML_TRACE_TYPE, 7, "22:01:20");
    private static final @NonNull TestTraceInfo CLASHES_LTTNG_KERNEL_TRACE = new TestTraceInfo("kernel-overlap-testing", CLASHES_DIR_NAME + "/kernel-overlap-testing", LTTNG_KERNEL_TRACE_TYPE, 1001, "04:32.650 993 664");
    private static final @NonNull TestTraceInfo CLASHES_SIMPLE_SERVER1_UST_TRACE = new TestTraceInfo("simple_server-thread1", CLASHES_DIR_NAME + "/simple_server-thread1", LTTNG_UST_TRACE_TYPE, 1001, "04:32.650 993 664");
    private static final @NonNull TestTraceInfo CLASHES_SIMPLE_SERVER2_UST_TRACE = new TestTraceInfo("simple_server-thread2", CLASHES_DIR_NAME + "/simple_server-thread2", LTTNG_UST_TRACE_TYPE, 1001, "04:32.650 993 664");
    private static final @NonNull TestTraceInfo CLASHES_UST_OVERLAP_TESTING_UST_TRACE = new TestTraceInfo("ust-overlap-testing", CLASHES_DIR_NAME + "/ust-overlap-testing", LTTNG_UST_TRACE_TYPE, 1001, "04:32.650 993 664");


    private static final @NonNull TestTraceInfo LTTNG_KERNEL_TRACE_METADATA = new TestTraceInfo(LTTNG_KERNEL_TRACE.getTraceName(), LTTNG_KERNEL_TRACE.getTraceName() + "/metadata", LTTNG_KERNEL_TRACE.getTraceType(), LTTNG_KERNEL_TRACE.getNbEvents(),
            LTTNG_KERNEL_TRACE.getFirstEventTimestamp());
    private static final @NonNull TestTraceInfo UNRECOGNIZED_LOG = new TestTraceInfo("unrecognized.log", "", 0, "");
    private static final @NonNull TestTraceInfo CUSTOM_XML_LOG_AS_TEXT = new TestTraceInfo("ExampleCustomXml.xml", CUSTOM_TEXT_TRACE_TYPE, 0, "");
    private static final @NonNull TestTraceInfo CLASHES_CUSTOM_XML_LOG_AS_TEXT = new TestTraceInfo("ExampleCustomXml.xml", CLASHES_DIR_NAME + "/ExampleCustomXml.xml", CUSTOM_TEXT_TRACE_TYPE, 0, "");

    private static final TestTraceInfo[] ALL_TRACEINFOS = new TestTraceInfo[] {
            CUSTOM_TEXT_LOG,
            CUSTOM_XML_LOG,
            LTTNG_KERNEL_TRACE,
            SIMPLE_SERVER1_UST_TRACE,
            SIMPLE_SERVER2_UST_TRACE,
            UST_OVERLAP_TESTING_UST_TRACE,

            CLASHES_CUSTOM_TEXT_LOG,
            CLASHES_CUSTOM_XML_LOG,
            CLASHES_LTTNG_KERNEL_TRACE,
            CLASHES_SIMPLE_SERVER1_UST_TRACE,
            CLASHES_SIMPLE_SERVER2_UST_TRACE,
            CLASHES_UST_OVERLAP_TESTING_UST_TRACE
    };

    private static final Set<TestTraceInfo> CLASHING_TRACEINFOS = ImmutableSet.of(
            CLASHES_CUSTOM_TEXT_LOG,
            CLASHES_CUSTOM_XML_LOG,
            CLASHES_LTTNG_KERNEL_TRACE,
            CLASHES_SIMPLE_SERVER1_UST_TRACE,
            CLASHES_SIMPLE_SERVER2_UST_TRACE,
            CLASHES_UST_OVERLAP_TESTING_UST_TRACE);

    // All normal traces plus the unrecognized trace
    private static final int NUM_UNIQUE_TRACES = CLASHING_TRACEINFOS.size() + 1;


    private static final File TEST_TRACES_PATH = new File(new Path(TmfTraceManager.getTemporaryDirPath()).append("testtraces").toOSString());
    private static final String DEFAULT_PROJECT_NAME = "Tracing";
    private static final String TRACE_PROJECT_NAME = "test";
    private static final String MANAGE_CUSTOM_PARSERS_SHELL_TITLE = "Manage Custom Parsers";

    private static SWTWorkbenchBot fBot;

    /** The Log4j logger instance. */
    private static final Logger fLogger = Logger.getRootLogger();

    private static final long DISK_ACCESS_TIMEOUT = 120000L;

    private static String getPath(String relativePath) {
        return new Path(TEST_TRACES_PATH.getAbsolutePath()).append(relativePath).toOSString();
    }

    /**
     * Test Class setup
     *
     * @throws IOException
     */
    @BeforeClass
    public static void init() throws IOException {
        TestDirectoryStructureUtil.generateTraceStructure(TEST_TRACES_PATH);

        SWTBotUtils.initialize();

        /* Set up for swtbot */
        SWTBotPreferences.TIMEOUT = 20000; /* 20 second timeout */
        SWTBotPreferences.KEYBOARD_LAYOUT = "EN_US";
        fLogger.removeAllAppenders();
        fLogger.addAppender(new ConsoleAppender(new SimpleLayout(), ConsoleAppender.SYSTEM_OUT));
        fBot = new SWTWorkbenchBot();

        /* Finish waiting for eclipse to load */
        WaitUtils.waitForJobs();
        SWTBotUtils.createProject(TRACE_PROJECT_NAME);
        importCustomParsers();
    }

    /**
     * Test class tear down method.
     */
    @AfterClass
    public static void tearDown() {
        SWTBotUtils.deleteProject(TRACE_PROJECT_NAME, fBot);
        SWTBotUtils.deleteProject(DEFAULT_PROJECT_NAME, fBot);
        fLogger.removeAllAppenders();
    }

    /**
     * Test tear down method.
     */
    @After
    public void afterTest() {
        SWTBotUtils.closeSecondaryShells(fBot);
    }

    private static void importCustomParsers() {
        // FIXME: We can't use Manage Custom Parsers > Import because it uses a native dialog. We'll still check that they show up in the dialog
        CustomTxtTraceDefinition[] txtDefinitions = CustomTxtTraceDefinition.loadAll(getPath("customParsers/ExampleCustomTxtParser.xml"));
        txtDefinitions[0].save();
        CustomXmlTraceDefinition[] xmlDefinitions = CustomXmlTraceDefinition.loadAll(getPath("customParsers/ExampleCustomXmlParser.xml"));
        xmlDefinitions[0].save();

        SWTBotTreeItem traceFolder = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        traceFolder.contextMenu("Manage Custom Parsers...").click();
        SWTBotShell shell = fBot.shell(MANAGE_CUSTOM_PARSERS_SHELL_TITLE).activate();
        SWTBot shellBot = shell.bot();

        // Make sure the custom text trace type is imported
        shellBot.list().select(CUSTOM_TEXT_LOG.getTraceType());

        // Make sure the custom xml trace type is imported
        shellBot.radio("XML").click();
        shellBot.list().select(CUSTOM_XML_LOG.getTraceType());
        shellBot.button("Close").click();
        shellBot.waitUntil(Conditions.shellCloses(shell), DISK_ACCESS_TIMEOUT);
    }

    /**
     * Test that the expected context menu items are there
     * <p>
     * Action : Trace Folder menu
     * <p>
     * Procedure :Select the Traces folder and open its context menu
     * <p>
     * Expected Results: Correct menu opens (Import, Refresh, etc)
     */
    @Test
    public void test3_01ContextMenuPresence() {
        SWTBotTreeItem traceItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);

        final List<String> EXPECTED_MENU_LABELS = ImmutableList.of(
                "Open Trace...",
                "Open As Experiment...",
                "",
                "Import...",
                "",
                "New Folder...",
                "Clear",
                "",
                "Import Trace Package...",
                "Fetch Remote Traces...",
                "",
                "Export Trace Package...",
                "",
                "Manage Custom Parsers...",
                "Manage XML analyses...",
                "",
                "Apply Time Offset...",
                "Clear Time Offset",
                "",
                "Refresh");

        List<String> menuLabels = traceItem.contextMenu().menuItems();
        for (int i = 0; i < menuLabels.size(); i++) {
            assertEquals(EXPECTED_MENU_LABELS.get(i), menuLabels.get(i));
        }

        fBot.closeAllEditors();
    }

    /**
     * Test that the trace import wizard appears
     * <p>
     * Action : Trace Import Wizard
     * <p>
     * Procedure : Select Import
     * <p>
     * Expected Results: Trace Import Wizard appears
     */
    @Test
    public void test3_02Import() {
        SWTBotTreeItem traceItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);

        SWTBotShell shell = openTraceFoldersImport(traceItem);
        shell.bot().button("Cancel").click();
    }

    /**
     * Test that the trace import wizard can import a single custom text trace
     * <p>
     * Action : Import single custom text trace (link to workspace)
     * <p>
     * <pre>
     * Procedure : 1) Browse to directory ${local}/traces/import/
     *             2) Select trace ExampleCustomTxt.log
     *             3) Keep <Auto Detection>, Select "Import unrecognized traces", unselect  "Overwrite existing without warning" and select "Create Links to workspace" and
     *             4) press Finish
     * </pre>
     * <p>
     * Expected Results: Imported trace appear in Traces Folder and the Trace Type Tmf Generic is set. Make sure trace can be opened
     */
    @Test
    public void test3_03SingleCustomTextTrace() {
        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES | ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        testSingleTrace(CUSTOM_TEXT_LOG, optionFlags);
    }

    /**
     * <p>
     * Action : Import Single custom XML trace (link to workspace)
     * <p>
     *
     * <pre>
     * Procedure : redo 3.1-3.3 but this time select ExampleCustomXml.xml
     * </pre>
     * <p>
     * Expected Results: Imported trace appear in Traces Folder and the Trace
     * Type "Custom XML log" is set. Make sure that trace can be opened
     */
    @Test
    public void test3_04SingleCustomXmlTrace() {
        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES | ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        testSingleTrace(CUSTOM_XML_LOG, optionFlags);
    }

    /**
     * <p>
     * Action : Import LTTng Kernel CTF trace (link to workspace)
     * <p>
     *
     * <pre>
     * Procedure : redo 3.1-3.3 but this time select directory kernel-overlap-testing/
     * </pre>
     * <p>
     * Expected Results: Imported trace appear in Traces Folder and the Trace
     * Type "LTTng Kernel" is set. Make sure that trace can be opened
     */
    @Test
    public void test3_05SingleCtfTrace() {
        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES | ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        testSingleTrace(LTTNG_KERNEL_TRACE, optionFlags);
    }

    /**
     * <p>
     * Action : Rename + copy import
     * <p>
     *
     * <pre>
     * Procedure : 1) redo 3.3, 3.4, 3.5. However, Unselect "Create Links to workspace"
     *             2) When dialog box appear select Rename
     * </pre>
     * <p>
     * Expected Results: Traces are imported with new name that has a suffix (2)
     * at the end. Make sure that imported traces are copied to the project.
     */
    @Test
    public void test3_06RenameCopyImport() {
        testRenameCopyImport(CUSTOM_TEXT_LOG);
        testRenameCopyImport(CUSTOM_XML_LOG);
        testRenameCopyImport(LTTNG_KERNEL_TRACE);
    }

    private static void testRenameCopyImport(TestTraceInfo traceInfo) {
        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES;
        importTrace(optionFlags, ImportConfirmation.RENAME, traceInfo.getTraceName());
        String renamed = toRenamedName(traceInfo.getTraceName());
        verifyTrace(traceInfo, optionFlags, renamed);
    }

    /**
     * <p>
     * Action : Overwrite + copy import
     * <p>
     *
     * <pre>
     * Procedure : 1) redo 3.3, 3.4, 3.5. However, Unselect "Create Links to workspace"
     *             2) When dialog box appear select Overwrite
     * </pre>
     * <p>
     * Expected Results: Existing traces are deleted and new traces are
     * imported. Make sure that imported traces are copied to the project and
     * can be opened
     */
    @Test
    public void test3_07OverwriteCopyImport() {
        testOverwriteCopyImport(CUSTOM_TEXT_LOG);
        testOverwriteCopyImport(CUSTOM_XML_LOG);
        testOverwriteCopyImport(LTTNG_KERNEL_TRACE);
    }

    private static void testOverwriteCopyImport(TestTraceInfo traceInfo) {
        String traceName = traceInfo.getTraceName();
        SWTBotTreeItem traceItem = SWTBotUtils.getTreeItem(fBot, SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME), traceName);
        String lastModified = getTraceProperty(traceItem, PROP_LAST_MODIFIED_PROPERTY);
        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES;
        importTrace(optionFlags, ImportConfirmation.OVERWRITE, traceName);
        verifyTrace(traceInfo, optionFlags);

        assertNotEquals(lastModified, getTraceProperty(traceItem, PROP_LAST_MODIFIED_PROPERTY));
    }

    /**
     * <p>
     * Action : Skip
     * <p>
     *
     * <pre>
     * Procedure : 1) redo 3.3, 3.4, 3.5. However, Unselect "Create Links to workspace"
     *             2) When dialog box appear select Skip
     * </pre>
     * <p>
     * Expected Results: Make sure that no new trace is imported
     */
    @Test
    public void test3_08SkipImport() {
        testSkipImport(CUSTOM_TEXT_LOG);
        testSkipImport(CUSTOM_XML_LOG);
        testSkipImport(LTTNG_KERNEL_TRACE);
    }

    private static void testSkipImport(TestTraceInfo traceInfo) {
        String traceName = traceInfo.getTraceName();
        SWTBotTreeItem traceItem = SWTBotUtils.getTreeItem(fBot, SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME), traceName);
        String lastModified = getTraceProperty(traceItem, PROP_LAST_MODIFIED_PROPERTY);
        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES;
        importTrace(optionFlags, ImportConfirmation.SKIP, traceName);
        verifyTrace(traceInfo, optionFlags);

        assertEquals(lastModified, getTraceProperty(traceItem, PROP_LAST_MODIFIED_PROPERTY));
    }

    /**
     * <p>
     * Action : Default overwrite
     * <p>
     *
     * <pre>
     * Procedure : 1) redo 3.3, 3.4, 3.5. However, Unselect "Create Links to workspace" and select "Overwrite existing without warning"
     * </pre>
     * <p>
     * Expected Results: Make sure that no dialog box appears (for renaming,
     * overwriting, skipping) and existing traces are overwritten). Make sure
     * trace can be opened
     */
    @Test
    public void test3_09OverwriteOptionImport() {
        testOverwriteOptionImport(CUSTOM_TEXT_LOG);
        testOverwriteOptionImport(CUSTOM_XML_LOG);
        testOverwriteOptionImport(LTTNG_KERNEL_TRACE);
    }

    private static void testOverwriteOptionImport(TestTraceInfo traceInfo) {
        String traceName = traceInfo.getTraceName();
        SWTBotTreeItem traceItem = SWTBotUtils.getTreeItem(fBot, SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME), traceName);
        String lastModified = getTraceProperty(traceItem, PROP_LAST_MODIFIED_PROPERTY);

        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES | ImportTraceWizardPage.OPTION_OVERWRITE_EXISTING_RESOURCES;
        importTrace(optionFlags, ImportConfirmation.CONTINUE, traceName);
        verifyTrace(traceInfo, optionFlags);

        assertNotEquals(lastModified, getTraceProperty(traceItem, PROP_LAST_MODIFIED_PROPERTY));
    }

    /**
     * <p>
     * Action : Import unrecognized
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard (see 3.1-3.2)
     *             2) Browse to directory ${local}/traces/import
     *             3) Select trace unrecognized.log
     *             4) Keep <Auto Detection>, Select "Import unrecognized traces", unselect  "Overwrite existing without warning" and select "Create Links to workspace" and
     *             5) press Finish
     * </pre>
     * <p>
     * Expected Results: unrecognized.log is imported with trace type unknown.
     * The default text file icon is displayed. The trace, when opened, is
     * displayed in the text editor.
     */
    @Test
    public void test3_10ImportUnrecognized() {
        String traceName = UNRECOGNIZED_LOG.getTraceName();
        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES | ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(optionFlags, traceName);
        verifyTrace(UNRECOGNIZED_LOG, optionFlags);
    }

    /**
     * <p>
     * Action : Import unrecognized (ignore)
     * <p>
     *
     * <pre>
     * Procedure : 1) redo 3.10, however unselect "Import unrecognized traces"
     * </pre>
     * <p>
     * Expected Results: unrecognized.log is not imported
     */
    @Test
    public void test3_11ImportUnrecognizedIgnore() {
        String traceName = UNRECOGNIZED_LOG.getTraceName();
        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        int numTraces = tracesFolderItem.getItems().length;

        SWTBotTreeItem traceItem = SWTBotUtils.getTreeItem(fBot, tracesFolderItem, traceName);
        String lastModified = getTraceProperty(traceItem, PROP_LAST_MODIFIED_PROPERTY);

        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(optionFlags, traceName);
        verifyTrace(UNRECOGNIZED_LOG, optionFlags);

        assertEquals(lastModified, getTraceProperty(traceItem, PROP_LAST_MODIFIED_PROPERTY));
        assertEquals(numTraces, tracesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Import CTF trace by selection metadata file only
     * <p>
     *
     * <pre>
     * Procedure : 1) Redo 3.5, However only select metadata file instead of directory trace
     * </pre>
     * <p>
     * Expected Results: Imported trace appear in Traces Folder and the Trace
     * Type "LTTng Kernel" is set. Make sure that trace can be opened
     */
    @Test
    public void test3_12ImportCtfWithMetadataSelection() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);
        testSingleTrace(LTTNG_KERNEL_TRACE_METADATA, ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES | ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE);
    }

    /**
     * <p>
     * Action : Recursive import with auto-detection (Rename All)
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard (see 3.1-3.2)
     *             2) Browse to directory ${local}/traces/import
     *             3) select directory import
     *             4) Keep <Auto Detection>, Select "Import unrecognized traces", unselect  "Overwrite existing without warning", select "Create Links to workspace" and unselect "Preserve Folder Structure"
     *             5) press Finish
     *             6) When dialog appears select "Rename All"
     * </pre>
     * <p>
     * Expected Results: All Traces are imported with respective trace type set.
     * Traces with name clashes are imported with suffix (2). 1 trace
     * (unrecognized.log) is imported with trace type unknown. Make sure that
     * traces can be opened which have a trace type set. The unknown trace type
     * should open with the text editor.
     */
    @Test
    public void test3_13ImportRecursiveAutoRenameAll() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES | ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(optionFlags, ImportConfirmation.RENAME_ALL, "");

        for (TestTraceInfo info : ALL_TRACEINFOS) {
            String traceName = info.getTraceName();
            if (CLASHING_TRACEINFOS.contains(info)) {
                traceName = toRenamedName(traceName);
            }
            verifyTrace(info, optionFlags, traceName);
        }

        // Also check unrecognized file
        verifyTrace(UNRECOGNIZED_LOG, optionFlags);
    }

    /**
     * <p>
     * Action : Recursive import with auto-detection (Overwrite All)
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard (see 3.1-3.2)
     *             2) Browse to directory ${local}/traces/import/
     *             3) select directory import
     *             4) Keep <Auto Detection>, Select "Import unrecognized traces", unselect  "Overwrite existing without warning", select "Create Links to workspace" and unselect "Preserve Folder Structure"
     *             5) press Finish
     *             6) When dialog appears select Overwrite All"
     * </pre>
     * <p>
     * Expected Results: All Traces are imported with respective trace type set.
     * Traces with name clashes are overwritten . 1 trace (unrecognized.log) is
     * imported with trace type unknown. Make sure that traces can be opened
     * which have a trace type set. The unknown trace type should open with the
     * text editor.
     */
    @Test
    public void test3_14ImportRecursiveAutoOverwriteAll() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES | ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(optionFlags, ImportConfirmation.OVERWRITE_ALL, "");

        for (TestTraceInfo info : CLASHING_TRACEINFOS) {
            verifyTrace(info, optionFlags);
        }

        // All traces should have clashed/overwritten (plus the unrecognized trace)
        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(NUM_UNIQUE_TRACES, tracesFolderItem.getItems().length);

        // Also check unrecognized file
        verifyTrace(UNRECOGNIZED_LOG, optionFlags);
    }

    /**
     * <p>
     * Action : Recursive import with auto-detection (Skip All)
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard (see 3.1-3.2)
     *             2) Browse to directory ${local}/traces/import/
     *             3) select directory import
     *             4) Keep <Auto Detection>, Select "Import unrecognized traces", unselect  "Overwrite existing without warning" and select "Create Links to workspace" and uncheck "preserve folder structure"
     *             5) press Finish
     *             6) When dialog appears select Skip All"
     * </pre>
     * <p>
     * Expected Results: All Traces are imported with respective trace type set. Traces with name
     * clashes are not imported. 1 trace (unrecognized.log) is imported with
     * trace type unknown. The unknown trace type should open with the text
     * editor.
     */
    @Test
    public void test3_15ImportRecursiveAutoSkipAll() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES | ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(optionFlags, ImportConfirmation.SKIP_ALL, "");

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        for (TestTraceInfo info : ALL_TRACEINFOS) {
            if (!CLASHING_TRACEINFOS.contains(info)) {
                verifyTrace(info, optionFlags);
            }
        }

        // All traces should have skipped (plus the unrecognized trace)
        assertEquals(NUM_UNIQUE_TRACES, tracesFolderItem.getItems().length);

        // Also check unrecognized file
        verifyTrace(UNRECOGNIZED_LOG, optionFlags);
    }

    /**
     * <p>
     * Action : Recursive import with auto-detection (test rename, overwrite and
     * skip)
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard (see 3.1-3.2)
     *             2) Browse to directory ${local}/traces/import/
     *             3) select directory import
     *             4) Keep <Auto Detection>, Select "Import unrecognized traces", unselect  "Overwrite existing without warning", select "Create Links to workspace" and unselect "Preserve Folder Structure"
     *             5) press Finish
     *             6) When dialog appears select "Rename"
     *             7) When dialog appears select "Overwrite"
     *             8) When dialog appears select "Skip"
     * </pre>
     * <p>
     * Expected Results: All Traces are imported with respective trace type set. Traces with name
     * clashes are either renamed, overwritten or skipped as per dialog action.
     * Make sure that traces can be opened which have trace type set. The
     * unknown trace type should open with the text editor.
     */
    @Test
    public void test3_16ImportRecursiveAutoRenameOverwriteSkip() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        Supplier<ImportConfirmation> confirmationSupplier = new ImportConfirmationSupplier(
                ImportConfirmation.RENAME, ImportConfirmation.OVERWRITE, ImportConfirmation.SKIP);
        int optionFlags = ImportTraceWizardPage.OPTION_IMPORT_UNRECOGNIZED_TRACES | ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(optionFlags, confirmationSupplier, LTTNG_KERNEL_TRACE.getTracePath(), CLASHES_LTTNG_KERNEL_TRACE.getTracePath(), SIMPLE_SERVER1_UST_TRACE.getTracePath(), CLASHES_SIMPLE_SERVER1_UST_TRACE.getTracePath(),
                SIMPLE_SERVER2_UST_TRACE.getTracePath(), CLASHES_SIMPLE_SERVER2_UST_TRACE.getTracePath(), UNRECOGNIZED_LOG.getTracePath());

        verifyTrace(LTTNG_KERNEL_TRACE, optionFlags);

        // Renamed trace
        String renamed = toRenamedName(CLASHES_LTTNG_KERNEL_TRACE.getTraceName());
        verifyTrace(CLASHES_LTTNG_KERNEL_TRACE, optionFlags, renamed);

        // Overwritten trace
        verifyTrace(CLASHES_SIMPLE_SERVER1_UST_TRACE, optionFlags);

        // Skipped trace
        verifyTrace(SIMPLE_SERVER2_UST_TRACE, optionFlags);

        // Also check unrecognized file
        verifyTrace(UNRECOGNIZED_LOG, optionFlags);
    }

    /**
     * <p>
     * Action : Recursive import with specific trace type 1 (Skip All) skip)
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard
     *             2) Browse to directory ${local}/traces/import/
     *             3) Select directory import
     *             4) Select trace type "Generic CTF Trace", unselect  "Overwrite existing without warning", select "Create Links to workspace" and unselect "Preserve Folder Structure"and
     *             5) press Finish
     *             6) When dialog appears select Skip All"
     * </pre>
     * <p>
     * Expected Results: After selecting trace type, verify that button "Import
     * unrecognized traces" is disabled. 4 CTF traces are imported with trace
     * type "Generic CTF Trace" . Make sure that these traces can be opened
     */
    @Test
    public void test3_17ImportRecursiveSpecifyTraceTypeCTF() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(GENERIC_CTF_TRACE_TYPE, optionFlags, ImportConfirmation.SKIP_ALL, "");

        final TestTraceInfo[] CTF_TRACEINFOS = new TestTraceInfo[] {
                LTTNG_KERNEL_TRACE,
                SIMPLE_SERVER1_UST_TRACE,
                SIMPLE_SERVER2_UST_TRACE,
                UST_OVERLAP_TESTING_UST_TRACE
        };
        for (TestTraceInfo info : CTF_TRACEINFOS) {
            verifyTrace(info, optionFlags, info.getTraceName(), GENERIC_CTF_TRACE_TYPE);
        }

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(CTF_TRACEINFOS.length, tracesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Recursive import with specific trace type 2 (Skip All)
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard (see 3.1-3.2)
     *             2) Browse to directory ${local}/traces/import/
     *             3) Select directory import
     *             4) Select trace type "LTTng Kernel Trace", unselect "Overwrite existing without warning", select "Create Links to workspace" and unselect "Preserve Folder Structure"
     *             5) Press Finish
     *             6) When dialog appears select Skip All"
     * </pre>
     * <p>
     * Expected Results: After selecting trace type, verify that button "Import
     * unrecognized traces" is disabled. One LTTng Kernel trace is imported with
     * trace type "LTTng Kernel Trace". Make sure that this trace can be opened.
     */
    @Test
    public void test3_18ImportRecursiveSpecifyTraceTypeKernel() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(LTTNG_KERNEL_TRACE_TYPE, optionFlags, ImportConfirmation.SKIP_ALL, "");

        verifyTrace(LTTNG_KERNEL_TRACE, optionFlags);

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(1, tracesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Recursive import with specific trace type 3 (Skip All)
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard
     *             2) Browse to directory ${local}/traces/import/
     *             3) Select directory import
     *             4) Select trace type "LTTng UST Trace", unselect "Overwrite existing without warning", select "Create Links to workspace" and unselect "Preserve Folder Structure"
     *             5) Press Finish
     *             6) When dialog appears select Skip All"
     * </pre>
     * <p>
     * Expected Results: After selecting trace type, verify that button "Import
     * unrecognized traces" is disabled. 3 LTTng UST traces are imported with
     * trace type "LTTng UST Trace". Make sure that these traces can be opened.
     */
    @Test
    public void test3_19ImportRecursiveSpecifyTraceTypeUST() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(LTTNG_UST_TRACE_TYPE, optionFlags, ImportConfirmation.SKIP_ALL, "");

        final TestTraceInfo[] UST_TRACEINFOS = new TestTraceInfo[] {
                SIMPLE_SERVER1_UST_TRACE,
                SIMPLE_SERVER2_UST_TRACE,
                UST_OVERLAP_TESTING_UST_TRACE
        };
        for (TestTraceInfo info : UST_TRACEINFOS) {
            verifyTrace(info, optionFlags);
        }

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(UST_TRACEINFOS.length, tracesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Recursive import with specific trace type 4 (Skip All)
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard (see 3.1-3.2)
     *             2) Browse to directory ${local}/traces/import/
     *             3) select directory import
     *             4) Select trace type "Tmf Generic", unselect  "Overwrite existing without warning", select "Create Links to workspace" and unselect "Preserve Folder Structure"
     *             5) press Finish
     *             6) When dialog appears select Skip All"
     * </pre>
     * <p>
     * Expected Results: All text files in directories are imported as trace and
     * trace type "Tmf Generic" is set. Note that trace type validation only
     * checks for file exists and that file is not a directory. Make sure that
     * these traces can be opened. However traces with wrong trace type won't
     * show any events in the table.
     */
    @Test
    public void test3_20ImportRecursiveSpecifyTraceTypeCustomText() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(CUSTOM_TEXT_TRACE_TYPE, optionFlags, ImportConfirmation.SKIP_ALL, "");

        final TestTraceInfo[] TEXT_BASED_TRACEINFOS = new TestTraceInfo[] {
                CUSTOM_TEXT_LOG,
                CUSTOM_XML_LOG_AS_TEXT,
                UNRECOGNIZED_LOG
        };
        for (TestTraceInfo info : TEXT_BASED_TRACEINFOS) {
            verifyTrace(info, optionFlags, info.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);
        }

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(TEXT_BASED_TRACEINFOS.length, tracesFolderItem.getItems().length);
    }

    /**
     * Action : Test the import wizard from workbench menu with project selected
     * <p>
     * <pre>
     * Procedure : 1) Select Project "Test" in Project Explorer view
     *             2) Open import wizard from menu File > Import... > Tracing > Trace Import
     *             3) Browse to directory ${local}/traces/import/
     *             4) Select trace ExampleCustomTxt.log
     *             5) Keep <Auto Detection>, select "Create Links to workspace" and
     *             6) press Finish
     * </pre>
     * <p>
     * Expected Results: Verify that trace is imported to "Test" project and can be opened.
     */
    @Test
    public void test3_21ImportFromMenuProjectSelected() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        SWTBotUtils.selectProject(fBot, TRACE_PROJECT_NAME);
        SWTBotShell shell = openWorkbenchMenuImport();
        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(shell, null, null, optionFlags, new ImportConfirmationSupplier(), CUSTOM_TEXT_LOG.getTracePath());
        verifyTrace(CUSTOM_TEXT_LOG, optionFlags);
    }

    /**
     * Action : Test the import wizard from workbench menu with no project selected
     * <p>
     * <pre>
     * Procedure : 1) Clear selection in Project Explorer view
     *             2) Open import wizard from menu File > Import... > Tracing > Trace Import
     *             3) Browse to directory ${local}/traces/import/
     *             4) Select trace ExampleCustomTxt.log
     *             5) Keep <Auto Detection>, select "Create Links to workspace" and
     *             6) press Finish
     * </pre>
     * <p>
     * Expected Results: Verify that trace is imported to default "Tracing" project and can be opened.
     */
    @Test
    public void test3_22ImportFromMenuProjectNotSelected() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        SWTBotView projectExplorerBot = fBot.viewByTitle("Project Explorer");
        projectExplorerBot.show();
        projectExplorerBot.bot().waitUntil(Conditions.widgetIsEnabled(projectExplorerBot.bot().tree()));
        projectExplorerBot.bot().tree().unselect();
        SWTBotShell shell = openWorkbenchMenuImport();
        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        importTrace(shell, null, null, optionFlags, new ImportConfirmationSupplier(), CUSTOM_TEXT_LOG.getTracePath());
        verifyTrace(CUSTOM_TEXT_LOG, optionFlags, CUSTOM_TEXT_LOG.getTraceName(), CUSTOM_TEXT_LOG.getTraceType(), DEFAULT_PROJECT_NAME);
        SWTBotUtils.deleteProject(DEFAULT_PROJECT_NAME, fBot);
    }

    /**
     * <p>
     * Action : Recursive import with preserved folder structure
     * <p>
     *
     * <pre>
     * Procedure : 0) Delete all traces in project
     *             1) Open Import wizard
     *             2) Browse to directory ${local}/traces/import/
     *             3) Select directory import
     *             4) Select trace type "Tmf Generic", unselect "Overwrite existing without warning", select "Create Links to workspace" and select "Preserve Folder Structure"
     *             5) press Finish
     * </pre>
     * <p>
     * Expected Results: All matching traces are imported with trace type set.
     * The folder "clashes" is imported with traces inside. Make sure that the
     * traces can be opened.
     */
    @Test
    public void test3_29ImportRecursivePreserve() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE | ImportTraceWizardPage.OPTION_PRESERVE_FOLDER_STRUCTURE;
        importTrace(CUSTOM_TEXT_TRACE_TYPE, optionFlags, ImportConfirmation.CONTINUE, "");

        verifyTrace(CUSTOM_TEXT_LOG, optionFlags, CUSTOM_TEXT_LOG.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(CUSTOM_XML_LOG_AS_TEXT, optionFlags, CUSTOM_XML_LOG_AS_TEXT.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(UNRECOGNIZED_LOG, optionFlags, UNRECOGNIZED_LOG.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(CLASHES_CUSTOM_TEXT_LOG, optionFlags, CLASHES_CUSTOM_TEXT_LOG.getTracePath(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(CLASHES_CUSTOM_XML_LOG_AS_TEXT, optionFlags, CLASHES_CUSTOM_XML_LOG_AS_TEXT.getTracePath(), CUSTOM_TEXT_TRACE_TYPE);

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(4, tracesFolderItem.getItems().length);
        SWTBotTreeItem clashesFolderItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolderItem, CLASHES_DIR_NAME);
        assertEquals(2, clashesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Recursive import with preserved folder structure (Skip All)
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard
     *             2) Browse to directory ${local}/traces/import/
     *             3) Select directory import
     *             4) Select trace type "Tmf Generic", unselect "Overwrite existing without warning", select "Create Links to workspace" and select "Preserve Folder Structure"
     *             5) press Finish
     *             6) When dialog appears select "Skip All"
     * </pre>
     * <p>
     * Expected Results: The wizard should finish quickly as no trace will be
     * imported. Make sure that the traces can be opened.
     */
    @Test
    public void test3_30ImportRecursivePreserveSkipAll() {
        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE | ImportTraceWizardPage.OPTION_PRESERVE_FOLDER_STRUCTURE;
        importTrace(CUSTOM_TEXT_TRACE_TYPE, optionFlags, ImportConfirmation.SKIP_ALL, "");

        verifyTrace(CUSTOM_TEXT_LOG, optionFlags, CUSTOM_TEXT_LOG.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(CUSTOM_XML_LOG_AS_TEXT, optionFlags, CUSTOM_XML_LOG_AS_TEXT.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(UNRECOGNIZED_LOG, optionFlags, UNRECOGNIZED_LOG.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(CLASHES_CUSTOM_TEXT_LOG, optionFlags, CLASHES_CUSTOM_TEXT_LOG.getTracePath(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(CLASHES_CUSTOM_XML_LOG_AS_TEXT, optionFlags, CLASHES_CUSTOM_XML_LOG_AS_TEXT.getTracePath(), CUSTOM_TEXT_TRACE_TYPE);

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(4, tracesFolderItem.getItems().length);
        SWTBotTreeItem clashesFolderItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolderItem, CLASHES_DIR_NAME);
        assertEquals(2, clashesFolderItem.getItems().length);
        //TOOD: verify that traces were actually skipped
    }

    /**
     * <p>
     * Action : Recursive import with preserved folder structure (Rename All)
     * <p>
     *
     * <pre>
     * Procedure : 1) Open Import wizard
     *             2) Browse to directory ${local}/traces/import/
     *             3) Select directory import
     *             4) Select trace type "Tmf Generic", unselect "Overwrite existing without warning", select "Create Links to workspace" and select "Preserve Folder Structure"
     *             5) press Finish
     *             6) When dialog appears select "Rename All"
     * </pre>
     * <p>
     * Expected Results: All matching traces are imported with trace type set.
     * The traces are renamed with suffix (2). The folder "clashes" is imported
     * with traces inside. Make sure that the traces can be opened.
     */
    @Test
    public void test3_31ImportRecursivePreserveRenameAll() {
        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE | ImportTraceWizardPage.OPTION_PRESERVE_FOLDER_STRUCTURE;
        importTrace(CUSTOM_TEXT_TRACE_TYPE, optionFlags, ImportConfirmation.RENAME_ALL, "");

        verifyTrace(CUSTOM_TEXT_LOG, optionFlags, toRenamedName(CUSTOM_TEXT_LOG.getTraceName()), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(CUSTOM_XML_LOG_AS_TEXT, optionFlags, toRenamedName(CUSTOM_XML_LOG_AS_TEXT.getTraceName()), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(UNRECOGNIZED_LOG, optionFlags, toRenamedName(UNRECOGNIZED_LOG.getTraceName()), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(CLASHES_CUSTOM_TEXT_LOG, optionFlags, toRenamedName(CLASHES_CUSTOM_TEXT_LOG.getTracePath()), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(CLASHES_CUSTOM_XML_LOG_AS_TEXT, optionFlags, toRenamedName(CLASHES_CUSTOM_XML_LOG_AS_TEXT.getTracePath()), CUSTOM_TEXT_TRACE_TYPE);

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(7, tracesFolderItem.getItems().length);
        SWTBotTreeItem clashesFolderItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolderItem, CLASHES_DIR_NAME);
        assertEquals(4, clashesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Delete with mixed selection of traces and folder
     * <p>
     *
     * <pre>
     * Procedure : 0) Delete all traces in project
     *             1) Create two trace folders under the "Traces" folder
     *             2) Import 2 traces under each folder
     *             3) Open all 4 traces.
     *             4) Select the trace in the first folder and the second folder in the Project Explorer view
     *             5) Right-click, Delete. Click Yes.
     * </pre>
     * <p>
     * Expected Results: A dialog should ask the user to confirm deletion of the
     * selected elements. Clicking OK should remove all that was selected. The
     * editor of the 3 deleted traces should be closed automatically with one
     * remaining editor opened.
     */
    @Test
    public void test3_32DeleteTraceAndFolder() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        SWTBotTreeItem tracesFolder = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        tracesFolder.contextMenu().menu("New Folder...").click();
        SWTBot newFolderShellBot = fBot.shell("New Folder").bot();
        newFolderShellBot.text().setText("FolderA");
        newFolderShellBot.button("OK").click();
        tracesFolder.contextMenu().menu("New Folder...").click();
        newFolderShellBot = fBot.shell("New Folder").bot();
        newFolderShellBot.text().setText("FolderB");
        newFolderShellBot.button("OK").click();

        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        SWTBotTreeItem traceFolder = SWTBotUtils.getTraceProjectItem(fBot, tracesFolder, "FolderA");
        SWTBotShell shell = openTraceFoldersImport(traceFolder);
        importTrace(shell, null, null, optionFlags, new ImportConfirmationSupplier(), CUSTOM_TEXT_LOG.getTracePath(), LTTNG_KERNEL_TRACE.getTracePath());
        verifyTrace(CUSTOM_TEXT_LOG, optionFlags, "FolderA/" + CUSTOM_TEXT_LOG.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(LTTNG_KERNEL_TRACE, optionFlags, "FolderA/" + LTTNG_KERNEL_TRACE.getTraceName(), LTTNG_KERNEL_TRACE_TYPE);

        traceFolder = SWTBotUtils.getTraceProjectItem(fBot, tracesFolder, "FolderB");
        shell = openTraceFoldersImport(traceFolder);
        importTrace(shell, null, null, optionFlags, new ImportConfirmationSupplier(), CUSTOM_TEXT_LOG.getTracePath(), LTTNG_KERNEL_TRACE.getTracePath());
        verifyTrace(CUSTOM_TEXT_LOG, optionFlags, "FolderB/" + CUSTOM_TEXT_LOG.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(LTTNG_KERNEL_TRACE, optionFlags, "FolderB/" + LTTNG_KERNEL_TRACE.getTraceName(), LTTNG_KERNEL_TRACE_TYPE);

        SWTBotTree tree = fBot.viewByTitle("Project Explorer").bot().tree();
        SWTBotTreeItem folderAItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolder, "FolderA");
        SWTBotTreeItem traceItem = SWTBotUtils.getTraceProjectItem(fBot, folderAItem, CUSTOM_TEXT_LOG.getTraceName());
        SWTBotTreeItem folderBItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolder, "FolderB");
        tree.select(traceItem, folderBItem);
        tree.contextMenu().menu("Delete").click();
        SWTBot deleteConfirmationShellBot = fBot.shell("Confirm Delete").bot();
        deleteConfirmationShellBot.button("Yes").click();
        fBot.waitWhile(ConditionHelpers.isEditorOpened(fBot, "FolderA/" + CUSTOM_TEXT_LOG.getTraceName()));
        fBot.waitWhile(ConditionHelpers.isEditorOpened(fBot, "FolderB/" + CUSTOM_TEXT_LOG.getTraceName()));
        fBot.waitWhile(ConditionHelpers.isEditorOpened(fBot, "FolderB/" + LTTNG_KERNEL_TRACE.getTraceName()));
        fBot.waitUntil(ConditionHelpers.isEditorOpened(fBot, "FolderA/" + LTTNG_KERNEL_TRACE.getTraceName()));
        SWTBotUtils.waitUntil(folder -> folder.getNodes().size() == 1, tracesFolder, "Traces folder not empty");
        SWTBotUtils.waitUntil(folder -> folder.getNodes().size() == 1, folderAItem, "Traces folder (folderAItem) not empty");
    }

    /**
     * <p>
     * Action : Delete with multiple folders
     * <p>
     *
     * <pre>
     * Procedure : 0) Delete all traces in project
     *             1) Create two trace folders under the "Traces" folder
     *             2) Import a trace under each folder
     *             3) Open both traces.
     *             4) Select both folders in the Project Explorer view
     *             5) Right-click, Delete. Click Yes.
     * </pre>
     * <p>
     * Expected Results: A dialog should ask the user to confirm deletion of the
     * selected elements. Clicking OK should remove all that was selected. The
     * editor of the 3 deleted traces should be closed automatically with one
     * remaining editor opened.
     */
    @Test
    public void test3_33DeleteMultipleFolders() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        SWTBotTreeItem tracesFolder = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        tracesFolder.contextMenu().menu("New Folder...").click();
        SWTBot newFolderShellBot = fBot.shell("New Folder").bot();
        newFolderShellBot.text().setText("FolderA");
        newFolderShellBot.button("OK").click();
        tracesFolder.contextMenu().menu("New Folder...").click();
        newFolderShellBot = fBot.shell("New Folder").bot();
        newFolderShellBot.text().setText("FolderB");
        newFolderShellBot.button("OK").click();

        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        SWTBotTreeItem traceFolder = SWTBotUtils.getTraceProjectItem(fBot, tracesFolder, "FolderA");
        SWTBotShell shell = openTraceFoldersImport(traceFolder);
        importTrace(shell, null, null, optionFlags, new ImportConfirmationSupplier(), CUSTOM_TEXT_LOG.getTracePath());
        verifyTrace(CUSTOM_TEXT_LOG, optionFlags, "FolderA/" + CUSTOM_TEXT_LOG.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);

        traceFolder = SWTBotUtils.getTraceProjectItem(fBot, tracesFolder, "FolderB");
        shell = openTraceFoldersImport(traceFolder);
        importTrace(shell, null, null, optionFlags, new ImportConfirmationSupplier(), LTTNG_KERNEL_TRACE.getTracePath());
        verifyTrace(LTTNG_KERNEL_TRACE, optionFlags, "FolderB/" + LTTNG_KERNEL_TRACE.getTraceName(), LTTNG_KERNEL_TRACE_TYPE);

        SWTBotTree tree = fBot.viewByTitle("Project Explorer").bot().tree();
        SWTBotTreeItem folderAItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolder, "FolderA");
        SWTBotTreeItem folderBItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolder, "FolderB");
        tree.select(folderAItem, folderBItem);
        tree.contextMenu().menu("Delete").click();
        SWTBot deleteConfirmationShellBot = fBot.shell("Confirm Delete").bot();
        deleteConfirmationShellBot.button("Yes").click();
        fBot.waitWhile(ConditionHelpers.isEditorOpened(fBot, "FolderA/" + CUSTOM_TEXT_LOG.getTraceName()));
        fBot.waitWhile(ConditionHelpers.isEditorOpened(fBot, "FolderB/" + LTTNG_KERNEL_TRACE.getTraceName()));
        SWTBotUtils.waitUntil(folder -> folder.getNodes().isEmpty(), tracesFolder, "Traces folder not empty");
    }

    /**
     * <p>
     * Action : Clear single Traces folder
     * <p>
     *
     * <pre>
     * Procedure : 1) Import 2 traces from different folders preserving folder structure
     *             2) Open both traces.
     *             3) Select the Traces folder
     *             4) Right-click, Clear. Click Yes.
     * </pre>
     * <p>
     * Expected Results: A dialog should ask the user to confirm clearing of the
     * folder. Clicking Yes should remove everything under the selected folder
     * and close the traces.
     */
    @Test
    public void test3_34ClearSingleTracesFolder() {
        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE | ImportTraceWizardPage.OPTION_PRESERVE_FOLDER_STRUCTURE;
        importTrace(CUSTOM_TEXT_TRACE_TYPE, optionFlags, ImportConfirmation.CONTINUE, CUSTOM_TEXT_LOG.getTraceName(), CLASHES_CUSTOM_TEXT_LOG.getTracePath());

        verifyTrace(CUSTOM_TEXT_LOG, optionFlags, CUSTOM_TEXT_LOG.getTraceName(), CUSTOM_TEXT_TRACE_TYPE);
        verifyTrace(CLASHES_CUSTOM_TEXT_LOG, optionFlags, CLASHES_CUSTOM_TEXT_LOG.getTracePath(), CUSTOM_TEXT_TRACE_TYPE);

        SWTBotTreeItem tracesFolder = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        tracesFolder.contextMenu().menu("Clear").click();
        SWTBot deleteConfirmationShellBot = fBot.shell("Confirm Clear").bot();
        deleteConfirmationShellBot.button("Yes").click();
        fBot.waitWhile(ConditionHelpers.isEditorOpened(fBot, CUSTOM_TEXT_LOG.getTraceName()));
        fBot.waitWhile(ConditionHelpers.isEditorOpened(fBot, CLASHES_CUSTOM_TEXT_LOG.getTracePath()));
        SWTBotUtils.waitUntil(folder -> folder.getNodes().size() == 0, tracesFolder, "Traces folder not empty");
    }

    /**
     * <p>
     * Action : Clear multiple Traces folder
     * <p>
     *
     * <pre>
     * Procedure : 1) Import 2 traces to different projects
     *             2) Open both traces.
     *             3) Select both Traces folders
     *             4) Right-click, Clear. Click Yes.
     * </pre>
     * <p>
     * Expected Results: A dialog should ask the user to confirm clearing of the
     * folders. Clicking Yes should remove everything under the selected folders
     * and close the traces.
     */
    @Test
    public void test3_35ClearMultipleTracesFolder() {
        int optionFlags = ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE;
        SWTBotTreeItem tracesFolder1 = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        SWTBotShell shell = openTraceFoldersImport(tracesFolder1);
        importTrace(shell, null, null, optionFlags, new ImportConfirmationSupplier(), CUSTOM_TEXT_LOG.getTracePath());
        verifyTrace(CUSTOM_TEXT_LOG, optionFlags, CUSTOM_TEXT_LOG.getTraceName(), CUSTOM_TEXT_TRACE_TYPE, TRACE_PROJECT_NAME);

        SWTBotUtils.createProject(DEFAULT_PROJECT_NAME);
        SWTBotTreeItem tracesFolder2 = SWTBotUtils.selectTracesFolder(fBot, DEFAULT_PROJECT_NAME);
        shell = openTraceFoldersImport(tracesFolder2);
        importTrace(shell, null, null, optionFlags, new ImportConfirmationSupplier(), LTTNG_KERNEL_TRACE.getTracePath());
        verifyTrace(LTTNG_KERNEL_TRACE, optionFlags, LTTNG_KERNEL_TRACE.getTraceName(), LTTNG_KERNEL_TRACE_TYPE, DEFAULT_PROJECT_NAME);

        SWTBotTree tree = fBot.viewByTitle("Project Explorer").bot().tree();
        tree.select(tracesFolder1, tracesFolder2);
        tree.contextMenu().menu("Clear").click();
        SWTBot deleteConfirmationShellBot = fBot.shell("Confirm Clear").bot();
        deleteConfirmationShellBot.button("Yes").click();
        fBot.waitWhile(ConditionHelpers.isEditorOpened(fBot, CUSTOM_TEXT_LOG.getTraceName()));
        fBot.waitWhile(ConditionHelpers.isEditorOpened(fBot, LTTNG_KERNEL_TRACE.getTraceName()));
        SWTBotUtils.waitUntil(folder -> folder.getNodes().isEmpty(), tracesFolder1, "Traces folder (tracesFolder1) not empty");
        SWTBotUtils.waitUntil(folder -> folder.getNodes().isEmpty(), tracesFolder2, "Traces folder (tracesFolder2) not empty");

        SWTBotUtils.deleteProject(DEFAULT_PROJECT_NAME, fBot);
    }

    /**
     * <p>
     * Action : Import from zip archive with preserved folder structure
     * <p>
     *
     * <pre>
     * Procedure : 0) Delete all traces in project
     *             1) Open Import wizard
     *             2) Select archive file: traces.zip
     *             3) Select archive root directory
     *             4) Select trace type "Automatic", unselect "Overwrite existing without warning", and select "Preserve Folder Structure"
     *             5) press Finish
     * </pre>
     * <p>
     * Expected Results: All traces are imported with trace type set. The folder
     * "clashes" is imported with traces inside. Make sure that the traces can
     * be opened.
     */
    @Test
    public void test3_36ImportZipArchivePreserve() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_PRESERVE_FOLDER_STRUCTURE;
        importTrace("traces.zip", null, optionFlags, ImportConfirmation.CONTINUE, "");

        for (TestTraceInfo info : ALL_TRACEINFOS) {
            verifyTrace(info, optionFlags, info.getTracePath());
        }

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(7, tracesFolderItem.getItems().length);
        SWTBotTreeItem clashesFolderItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolderItem, CLASHES_DIR_NAME);
        assertEquals(6, clashesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Import from zip archive without preserved folder structure
     * (Rename All)
     * <p>
     *
     * <pre>
     * Procedure : 0) Delete all traces in project
     *             1) Open Import wizard
     *             2) Select archive file: traces.zip
     *             3) Select archive root directory
     *             4) Select trace type "Automatic", unselect "Overwrite existing without warning", and unselect "Preserve Folder Structure"
     *             5) press Finish
     *             6) When dialog appears select "Rename All"
     * </pre>
     * <p>
     * Expected Results: All traces are imported with trace type set. The traces
     * from folder "clashes" are renamed with suffix (2). Make sure that the
     * traces can be opened.
     */
    @Test
    public void test3_37ImportZipArchiveNoPreserve() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = 0;
        importTrace("traces.zip", null, optionFlags, ImportConfirmation.RENAME_ALL, "");

        for (TestTraceInfo info : ALL_TRACEINFOS) {
            String traceName = info.getTraceName();
            if (CLASHING_TRACEINFOS.contains(info)) {
                traceName = toRenamedName(traceName);
            }
            verifyTrace(info, optionFlags, traceName);
        }

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(12, tracesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Import from zip archive specific traces
     * <p>
     *
     * <pre>
     * Procedure : 0) Delete all traces in project
     *             1) Open Import wizard
     *             2) Select archive file: traces.zip
     *             3) Select file z-clashes/ExampleCustomTxt.log and directory kernel-overlap-testing/
     *             4) Select trace type "Automatic", unselect "Overwrite existing without warning", and select "Preserve Folder Structure"
     *             5) press Finish
     * </pre>
     * <p>
     * Expected Results: The specified traces are imported with trace type set.
     * Make sure that the traces can be opened.
     */
    @Test
    public void test3_38ImportZipArchiveSpecificTraces() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_PRESERVE_FOLDER_STRUCTURE;
        importTrace("traces.zip", null, optionFlags, ImportConfirmation.CONTINUE, "z-clashes/ExampleCustomTxt.log", "kernel-overlap-testing/");

        verifyTrace(CLASHES_CUSTOM_TEXT_LOG, optionFlags, CLASHES_CUSTOM_TEXT_LOG.getTracePath());
        verifyTrace(LTTNG_KERNEL_TRACE, optionFlags, LTTNG_KERNEL_TRACE.getTracePath());

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(2, tracesFolderItem.getItems().length);
        SWTBotTreeItem clashesFolderItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolderItem, CLASHES_DIR_NAME);
        assertEquals(1, clashesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Import from tar.gz archive with preserved folder structure
     * <p>
     *
     * <pre>
     * Procedure : 0) Delete all traces in project
     *             1) Open Import wizard
     *             2) Select archive file: traces.tar.gz
     *             3) Select archive root directory
     *             4) Select trace type "Automatic", unselect "Overwrite existing without warning", and select "Preserve Folder Structure"
     *             5) press Finish
     * </pre>
     * <p>
     * Expected Results: All traces are imported with trace type set. The folder
     * "clashes" is imported with traces inside. Make sure that the traces can
     * be opened.
     */
    @Test
    public void test3_39ImportTarGzipArchivePreserve() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_PRESERVE_FOLDER_STRUCTURE;
        importTrace("traces.tar.gz", null, optionFlags, ImportConfirmation.CONTINUE, "");

        for (TestTraceInfo info : ALL_TRACEINFOS) {
            verifyTrace(info, optionFlags, info.getTracePath());
        }

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(7, tracesFolderItem.getItems().length);
        SWTBotTreeItem clashesFolderItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolderItem, CLASHES_DIR_NAME);
        assertEquals(6, clashesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Import from tar.gz archive without preserved folder structure (Rename All)
     * <p>
     *
     * <pre>
     * Procedure : 0) Delete all traces in project
     *             1) Open Import wizard
     *             2) Select archive file: traces.tar.gz
     *             3) Select archive root directory
     *             4) Select trace type "Automatic", unselect "Overwrite existing without warning", and unselect "Preserve Folder Structure"
     *             5) press Finish
     *             6) When dialog appears select "Rename All"
     * </pre>
     * <p>
     * Expected Results: All traces are imported with trace type set. The traces
     * from folder "clashes" are renamed with suffix (2). Make sure that the
     * traces can be opened.
     */
    @Test
    public void test3_40ImportTarGzipArchiveNoPreserve() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = 0;
        importTrace("traces.tar.gz", null, optionFlags, ImportConfirmation.RENAME_ALL, "");

        for (TestTraceInfo info : ALL_TRACEINFOS) {
            String traceName = info.getTraceName();
            if (CLASHING_TRACEINFOS.contains(info)) {
                traceName = toRenamedName(traceName);
            }
            verifyTrace(info, optionFlags, traceName);
        }

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(12, tracesFolderItem.getItems().length);
    }

    /**
     * <p>
     * Action : Import from tar.gz archive specific traces
     * <p>
     *
     * <pre>
     * Procedure : 0) Delete all traces in project
     *             1) Open Import wizard
     *             2) Select archive file: traces.tar.gz
     *             3) Select file z-clashes/ExampleCustomTxt.log and directory kernel-overlap-testing/
     *             4) Select trace type "Automatic", unselect "Overwrite existing without warning", and select "Preserve Folder Structure"
     *             5) press Finish
     * </pre>
     * <p>
     * Expected Results: The specified traces are imported with trace type set.
     * Make sure that the traces can be opened.
     */
    @Test
    public void test3_41ImportTarGzipArchiveSpecificTraces() {
        SWTBotUtils.clearTracesFolderUI(fBot, TRACE_PROJECT_NAME);

        int optionFlags = ImportTraceWizardPage.OPTION_PRESERVE_FOLDER_STRUCTURE;
        importTrace("traces.tar.gz", null, optionFlags, ImportConfirmation.CONTINUE, "z-clashes/ExampleCustomTxt.log", "kernel-overlap-testing/");

        verifyTrace(CLASHES_CUSTOM_TEXT_LOG, optionFlags, CLASHES_CUSTOM_TEXT_LOG.getTracePath());
        verifyTrace(LTTNG_KERNEL_TRACE, optionFlags, LTTNG_KERNEL_TRACE.getTracePath());

        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        assertEquals(2, tracesFolderItem.getItems().length);
        SWTBotTreeItem clashesFolderItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolderItem, CLASHES_DIR_NAME);
        assertEquals(1, clashesFolderItem.getItems().length);
    }

    @Test
    public void test_RenameFolderWorkaroundBug525833() {
        // Create Folder 'aaa'
        SWTBotTreeItem tracesFolderItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        tracesFolderItem.contextMenu().menu("New Folder...").click();
        final String NEW_FOLDER_DIALOG_TITLE = "New Folder";
        SWTBotShell shell = fBot.shell(NEW_FOLDER_DIALOG_TITLE).activate();

        SWTBotText text = shell.bot().textWithLabel("Folder name:");
        final String FOLDER_NAME = "aaa";
        text.setText(FOLDER_NAME);
        shell.bot().button("OK").click();
        fBot.waitUntil(Conditions.shellCloses(shell), DISK_ACCESS_TIMEOUT);

        // Import (link) CTF trace to folder 'aaa'
        SWTBotTreeItem folderItem = SWTBotUtils.getTraceProjectItem(fBot, tracesFolderItem, FOLDER_NAME);
        shell = openTraceFoldersImport(folderItem);
        importTrace(shell, null, null, ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE, new ImportConfirmationSupplier(ImportConfirmation.CONTINUE), LTTNG_KERNEL_TRACE.getTracePath());

        // Create Experiment
        final String EXP_NAME = "exp";
        SWTBotUtils.createExperiment(fBot, TRACE_PROJECT_NAME, EXP_NAME);
        SWTBotTreeItem project = SWTBotUtils.selectProject(fBot, TRACE_PROJECT_NAME);
        SWTBotTreeItem experiment = SWTBotUtils.getTraceProjectItem(fBot, project, "Experiments", EXP_NAME);

        folderItem.expand();
        folderItem.getNode(LTTNG_KERNEL_TRACE.getTraceName()).dragAndDrop(experiment);
        experiment.expand();

        // Rename Trace Folder
        final String NEW_FOLDER_NAME = "bbb";
        folderItem.contextMenu().menu("Rename...").click();
        final String RENAME_FOLDER_DIALOG_TITLE = "Rename Folder";
        shell = fBot.shell(RENAME_FOLDER_DIALOG_TITLE).activate();
        text = shell.bot().textWithLabel("New Folder name:");
        text.setText(NEW_FOLDER_NAME);
        shell.bot().button("OK").click();
        fBot.waitUntil(Conditions.shellCloses(shell), DISK_ACCESS_TIMEOUT);

        // verify that trace reference have been updated after rename
        SWTBotTreeItem expTrace = SWTBotUtils.getTraceProjectItem(fBot, project, "Experiments", EXP_NAME, NEW_FOLDER_NAME + "/" + LTTNG_KERNEL_TRACE.getTraceName());
        assertEquals(NEW_FOLDER_NAME + "/" + LTTNG_KERNEL_TRACE.getTraceName(), expTrace.getText());

        // verify that workaround for bug 525833 deleted all lingering directories
        SWTBotTreeItem exp = SWTBotUtils.getTraceProjectItem(fBot, project, "Experiments", EXP_NAME);
        SWTBotTreeItem tracesItem = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        IStatus status = UIThreadRunnable.syncExec(new Result<IStatus>() {
            @Override
            public IStatus run() {
                final String PLUGIN_ID = "org.eclipse.tracecompass.integration.swtbot.tests";
                // Check that no lingering directories in experiment folder
                Object expObj = exp.widget.getData();
                if (expObj instanceof TmfExperimentElement) {
                    TmfExperimentElement tmfExp = (TmfExperimentElement) expObj;
                    IFolder expFolder = tmfExp.getResource();
                    String path = expFolder.getLocation().toOSString();
                    File fileSystemPath = new File(path);
                    if (fileSystemPath.isDirectory()) {
                        for (File file : fileSystemPath.listFiles()) {
                            if (FOLDER_NAME.equals(file.getName())) {
                                return new Status(IStatus.ERROR, PLUGIN_ID, FOLDER_NAME + " exists under experiment!", null);
                            }
                        }
                    }
                }
                // Check that no lingering directories in traces folder
                Object tracesFolderObj = tracesItem.widget.getData();
                if (tracesFolderObj instanceof TmfTracesFolder) {
                    TmfTracesFolder tmfTracesFolder = (TmfTracesFolder) tracesFolderObj;
                    IFolder tFolder = tmfTracesFolder.getResource();
                    String path = tFolder.getLocation().toOSString();
                    File fileSystemPath = new File(path);
                    if (fileSystemPath.isDirectory()) {
                        for (File file : fileSystemPath.listFiles()) {
                            if (FOLDER_NAME.equals(file.getName())) {
                                return new Status(IStatus.ERROR, PLUGIN_ID, FOLDER_NAME + " exists in trace folder!", null);
                            }
                        }
                    }
                }
                return Status.OK_STATUS;
            }
        });

        if (!status.isOK()) {
            fail(status.getMessage());
        }
    }

    private static void verifyTrace(TestTraceInfo traceInfo, int importOptionFlags) {
        verifyTrace(traceInfo, importOptionFlags, traceInfo.getTraceName());
    }

    private static void verifyTrace(TestTraceInfo traceInfo, int importOptionFlags, String traceName) {
        verifyTrace(traceInfo, importOptionFlags, traceName, traceInfo.getTraceType());
    }

    private static void verifyTrace(TestTraceInfo traceInfo, int importOptionFlags, String traceName, String traceType) {
        verifyTrace(traceInfo, importOptionFlags, traceName, traceType, TRACE_PROJECT_NAME);
    }

    private static void verifyTrace(TestTraceInfo traceInfo, int importOptionFlags, String traceName, String traceType, String projectName) {
        String[] tracePath = new Path(traceName).segments();
        SWTBotTreeItem traceItem = SWTBotUtils.getTraceProjectItem(fBot, SWTBotUtils.selectTracesFolder(fBot, projectName), tracePath);
        checkTraceType(traceItem, traceType);
        openTrace(traceItem);
        if (traceType != null && !traceType.isEmpty()) {
            SWTBotImportWizardUtils.testEventsTable(fBot, traceName, traceInfo.getNbEvents(), traceInfo.getFirstEventTimestamp());
        } else {
            // If there is no trace type, make sure it can be opened with the text editor
            fBot.waitUntil(ConditionHelpers.isEditorOpened(fBot, traceName));
            SWTBotEditor editor = fBot.editorByTitle(traceName);
            assertEquals(TEXT_EDITOR_ID, editor.getReference().getId());
        }
        checkTraceLinked(traceItem, (importOptionFlags & ImportTraceWizardPage.OPTION_CREATE_LINKS_IN_WORKSPACE) != 0);
    }

    private static String toRenamedName(String traceName) {
        return traceName + "(2)";
    }

    private static void openTrace(SWTBotTreeItem traceItem) {
        traceItem.select();
        traceItem.doubleClick();
    }

    private static void testSingleTrace(TestTraceInfo traceInfo, int optionFlags) {
        importTrace(optionFlags, traceInfo.getTracePath());
        verifyTrace(traceInfo, optionFlags);
    }

    private static void importTrace(int optionFlags, String ... tracePaths) {
        importTrace(optionFlags, ImportConfirmation.CONTINUE, tracePaths);
    }

    private static void importTrace(int optionFlags, ImportConfirmation confirmationMode, String ... tracePaths) {
        importTrace(null, optionFlags, confirmationMode, tracePaths);
    }

    private static void importTrace(String traceType, int optionFlags, ImportConfirmation confirmationMode, String ... tracePaths) {
        importTrace(null, traceType, optionFlags, confirmationMode, tracePaths);
    }

    private static void importTrace(String archiveFile, String traceType, int optionFlags, ImportConfirmation confirmationMode, String ... tracePaths) {
        importTrace(archiveFile, traceType, optionFlags, new ImportConfirmationSupplier(confirmationMode), tracePaths);
    }

    private static void importTrace(int optionFlags, Supplier<ImportConfirmation> confirmationSuplier, String ... tracePaths) {
        importTrace(null, null, optionFlags, confirmationSuplier, tracePaths);
    }

    private static void importTrace(String archiveFile, String traceType, int optionFlags, Supplier<ImportConfirmation> confirmationSuplier, String ... tracePaths) {
        SWTBotTreeItem traceFolder = SWTBotUtils.selectTracesFolder(fBot, TRACE_PROJECT_NAME);
        SWTBotShell shell = openTraceFoldersImport(traceFolder);
        importTrace(shell, archiveFile, traceType, optionFlags, confirmationSuplier, tracePaths);
    }

    /**
     * @param tracePaths relative to parent test traces folder
     */
    private static void importTrace(SWTBotShell shell, String archiveFile, String traceType, int optionFlags, Supplier<ImportConfirmation> confirmationSuplier, String ... tracePaths) {
        SWTBot bot = shell.bot();
        String rootFolderName;
        if (archiveFile == null) {
            rootFolderName = "import";
            String importDirectoryFullPath = getPath(rootFolderName);
            SWTBotImportWizardUtils.selectImportFromDirectory(bot, importDirectoryFullPath);
        } else {
            rootFolderName = "/";
            String importArchiveFullPath = getPath("archives" + File.separator + archiveFile);
            SWTBotImportWizardUtils.selectImportFromArchive(bot, importArchiveFullPath);
        }

        for (String tracePath : tracePaths) {
            IPath somePath = new Path(rootFolderName).append(tracePath);
            String[] treePath = somePath.segments();
            if (archiveFile != null) {
                String[] newPath = new String[treePath.length + 1];
                newPath[0] = "/";
                System.arraycopy(treePath, 0, newPath, 1, treePath.length);
                treePath = newPath;
            }
            SWTBotImportWizardUtils.selectItem(fBot, treePath);
        }

        SWTBotImportWizardUtils.setOptions(bot, optionFlags, traceType);
        bot.button("Finish").click();

        ImportConfirmation importConfirmation = confirmationSuplier.get();
        while (importConfirmation != null) {
            if (importConfirmation != ImportConfirmation.CONTINUE) {
                SWTBotShell shell2 = fBot.shell("Confirmation").activate();
                SWTBotButton button = shell2.bot().button(importConfirmation.getInName());
                button.click();
            }
            importConfirmation = confirmationSuplier.get();
        }

        fBot.waitUntil(Conditions.shellCloses(shell), DISK_ACCESS_TIMEOUT);
    }

    private static void checkTraceType(SWTBotTreeItem traceItem, String traceType) {
        assertEquals(traceType, getTraceProperty(traceItem, "type"));
    }

    private static void checkTraceLinked(SWTBotTreeItem traceItem, boolean linked) {
        assertEquals(Boolean.toString(linked), getTraceProperty(traceItem, "linked"));
    }

    private static String getTraceProperty(SWTBotTreeItem traceItem, String property) {
        SWTBotUtils.openView(IPageLayout.ID_PROP_SHEET);
        SWTBotView view = fBot.viewById(IPageLayout.ID_PROP_SHEET);
        view.show();
        traceItem.select();
        SWTBot viewBot = view.bot();
        SWTBotUtils.waitUntil(bot -> bot.tree().cell(0, 0).equals(RESOURCE_PROPERTIES), viewBot, "Resource properties did not appear");
        SWTBotTreeItem traceTypeItem = SWTBotUtils.getTreeItem(viewBot, viewBot.tree(), RESOURCE_PROPERTIES, property);
        return traceTypeItem.cell(1);
    }

    private static SWTBotShell openTraceFoldersImport(SWTBotTreeItem traceItem) {
        traceItem.contextMenu().menu("Import...").click();

        return fBot.shell("Trace Import").activate();
    }

    private static SWTBotShell openWorkbenchMenuImport() {
        fBot.menu().menu("File", "Import...").click();

        SWTBot shellBot = fBot.shell("Import").activate().bot();
        SWTBotTree tree = shellBot.tree();
        SWTBotUtils.getTreeItem(fBot, tree, "Tracing", "Trace Import").select();
        shellBot.button("Next >").click();
        SWTBotShell shell = fBot.shell("Trace Import");
        return shell;
    }

}
