| /******************************************************************************* |
| * Copyright (c) 2009, 2019 Xored Software Inc and others. |
| * 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 |
| * https://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * Xored Software Inc - initial API and implementation and/or initial documentation |
| *******************************************************************************/ |
| package org.eclipse.rcptt.core; |
| |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.util.EContentAdapter; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.rcptt.ecl.core.CoreFactory; |
| import org.eclipse.rcptt.ecl.core.Script; |
| |
| import org.eclipse.rcptt.core.model.ITestCase; |
| import org.eclipse.rcptt.core.model.ModelException; |
| import org.eclipse.rcptt.core.model.search.Q7SearchCore; |
| import org.eclipse.rcptt.core.scenario.Scenario; |
| import org.eclipse.rcptt.core.scenario.ScenarioPackage; |
| import org.eclipse.rcptt.tesla.core.protocol.raw.TeslaScenario; |
| import org.eclipse.rcptt.tesla.recording.core.ecl.EclRecorder; |
| |
| public class Scenarios { |
| |
| public static final String ECL_SCENARIO_TYPE = "ecl"; |
| |
| public static final String TESLA_SCENARIO_TYPE = "tesla"; |
| |
| public static class ScenarioTypeWatcher extends EContentAdapter { |
| static final ScenarioTypeWatcher INSTANCE = new ScenarioTypeWatcher(); |
| private static final EAttribute feature = ScenarioPackage.eINSTANCE.getScenario_Type(); |
| |
| private ScenarioTypeWatcher() { |
| } |
| |
| @Override |
| public void notifyChanged(Notification notification) { |
| super.notifyChanged(notification); |
| if (notification.getEventType() == Notification.REMOVING_ADAPTER) |
| return; |
| if (feature.equals(notification.getFeature())) { |
| Scenario scenario = (Scenario) notification.getNotifier(); |
| String value = notification.getNewStringValue(); |
| if (ECL_SCENARIO_TYPE.equals(value)) |
| setTypeToEcl(scenario); |
| else if (TESLA_SCENARIO_TYPE.equals(value)) |
| setTypeToEcl(scenario); |
| } |
| } |
| } |
| |
| public static boolean isEclMode(Scenario scenario) { |
| return ECL_SCENARIO_TYPE.equals(getScenarioType(scenario, ECL_SCENARIO_TYPE)); |
| } |
| |
| public static boolean isTeslaMode(Scenario scenario) { |
| return TESLA_SCENARIO_TYPE.equals(getScenarioType(scenario, ECL_SCENARIO_TYPE)); |
| } |
| |
| public static String getScenarioType(Scenario scenario, String def) { |
| String type = scenario.getType(); |
| if (type != null) |
| return type; |
| EObject content = scenario.getContent(); |
| if (content != null) { |
| return content instanceof Script ? ECL_SCENARIO_TYPE : TESLA_SCENARIO_TYPE; |
| } |
| return def; |
| } |
| |
| public static class ObsoleteEclFormatException extends RuntimeException { |
| private static final long serialVersionUID = 6956202972837349383L; |
| } |
| |
| public static class UserModificationException extends RuntimeException { |
| private static final long serialVersionUID = 825351484816358064L; |
| } |
| |
| /** |
| * Set scenario type to ECL. Returns true if scenario was changed during |
| * this operation and false otherwise. Scenario won't be changed if it |
| * already has ECL type. |
| * |
| * @param scenario |
| * @return true if scenario was changed and false otherwise. |
| */ |
| public static boolean setTypeToEcl(Scenario scenario) { |
| switch (getScenarioMode(scenario)) { |
| case strictTesla: |
| scenario.setTeslaContent(scenario.getContent()); |
| case tesla: |
| scenario.setType(ECL_SCENARIO_TYPE); |
| scenario.setContent(null); |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Set scenario type to Tesla. Returns true if scenario was changed during |
| * this operation and false otherwise. Scenario won't be changed if it |
| * already has Tesla type or if it has ECL type but wasn't edited by user |
| * yet. |
| * |
| * @param scenario |
| * @param discardUserChanges |
| * @return true if scenario was changed and false otherwise. |
| * @throws ObsoleteEclFormatException |
| * if scenario format is not support such conversion. |
| * @throws UserModificationException |
| * discardUserChanges is false and user changes cannot be saved. |
| */ |
| public static boolean setTypeToTesla(Scenario scenario, boolean discardUserChanges) { |
| ScenarioMode mode = getScenarioMode(scenario); |
| switch (mode) { |
| case strictEcl: |
| throw new ObsoleteEclFormatException(); |
| case ecl: |
| if (scenario.getContent() != null && !discardUserChanges) |
| throw new UserModificationException(); |
| scenario.setType(TESLA_SCENARIO_TYPE); |
| scenario.setContent(null); |
| return true; |
| } |
| return false; |
| } |
| |
| public static boolean hasUserModifications(Scenario scenario) { |
| ScenarioMode mode = getScenarioMode(scenario); |
| switch (mode) { |
| case strictEcl: |
| return true; |
| case ecl: |
| return scenario.getContent() != null; |
| // TODO Script eclScript = (Script) scenario.getContent(); |
| // if (eclScript == null) |
| // return false; |
| // |
| // String teslaScript = new EclRecorder() |
| // .generateCode(getTesla(scenario)); |
| // Command teslaContent; |
| // Command eclContent; |
| // try { |
| // teslaContent = EclCoreParser.newCommand(teslaScript); |
| // eclContent = EclCoreParser.newCommand(eclScript.getContent()); |
| // } catch (CoreException e) { |
| // Q7Plugin.log(e); |
| // return true; |
| // } |
| // return !EcoreUtil.equals(eclContent, teslaContent); |
| } |
| return false; |
| } |
| |
| public static boolean hasObsoleteEclFormat(Scenario scenario) { |
| return getScenarioMode(scenario) == ScenarioMode.strictEcl; |
| } |
| |
| public static boolean hasObsoleteTeslaFormat(Scenario scenario) { |
| return getScenarioMode(scenario) == ScenarioMode.strictTesla; |
| } |
| |
| public static boolean hasTesla(Scenario scenario) { |
| if (scenario.getContent() instanceof TeslaScenario) { |
| return true; |
| } else if (scenario.getTeslaContent() instanceof TeslaScenario) { |
| return true; |
| } |
| return false; |
| } |
| |
| public static TeslaScenario getTesla(Scenario scenario) { |
| if (scenario.getContent() instanceof TeslaScenario) { |
| return (TeslaScenario) scenario.getContent(); |
| } else if (scenario.getTeslaContent() instanceof TeslaScenario) { |
| return (TeslaScenario) scenario.getTeslaContent(); |
| } |
| return null; |
| } |
| public static TeslaScenario getTesla(ITestCase scenario) throws ModelException { |
| if (scenario.getContent() instanceof TeslaScenario) { |
| return (TeslaScenario) scenario.getContent(); |
| } else if (scenario.getTesla() instanceof TeslaScenario) { |
| return (TeslaScenario) scenario.getTesla(); |
| } |
| return null; |
| } |
| |
| public static void setTesla(Scenario scenario, TeslaScenario tesla) { |
| if (hasObsoleteTeslaFormat(scenario)) { |
| scenario.setContent(tesla); |
| } else { |
| scenario.setTeslaContent(tesla); |
| } |
| } |
| |
| public static boolean hasEcl(Scenario scenario) { |
| return scenario.getContent() instanceof Script; |
| } |
| |
| public static boolean isEmpty(ITestCase test) { |
| try { |
| Boolean value = Q7SearchCore.findIsEmptyByDocument(test); |
| if( value != null) { |
| return value.booleanValue(); |
| } |
| |
| if (test.getNamedElement() instanceof Scenario) { |
| Scenario scenario = (Scenario)test.getNamedElement(); |
| return isEmpty(scenario); |
| } |
| } catch (Exception e) { |
| // ignore exception |
| } |
| return false; |
| } |
| |
| public static boolean isEmpty(Scenario scenario) { |
| Script script = getEcl(scenario); |
| if (script != null) { |
| String content = script.getContent(); |
| if (content != null && content.length() > 0) |
| return false; |
| } |
| return true; |
| } |
| |
| public static Script getEcl(Scenario scenario) { |
| if (scenario.getContent() instanceof Script) { |
| return (Script) scenario.getContent(); |
| } |
| TeslaScenario tesla = getTesla(scenario); |
| if (tesla == null) { |
| return null; |
| } else { |
| Script script = CoreFactory.eINSTANCE.createScript(); |
| script.setContent(new EclRecorder().generateCode(tesla)); |
| return script; |
| } |
| } |
| public static Script getEcl(ITestCase scenario) throws ModelException { |
| if (scenario.getContent() instanceof Script) { |
| return (Script) scenario.getContent(); |
| } |
| TeslaScenario tesla = getTesla(scenario); |
| if (tesla == null) { |
| return null; |
| } else { |
| Script script = CoreFactory.eINSTANCE.createScript(); |
| script.setContent(new EclRecorder().generateCode(tesla)); |
| return script; |
| } |
| } |
| |
| public static void setEcl(Scenario scenario, Script script) { |
| if (isEclMode(scenario)) { |
| if (!EcoreUtil.equals(script, scenario.getContent())) |
| scenario.setContent(script); |
| } else { |
| throw new IllegalArgumentException(); |
| } |
| } |
| |
| public static void setEclContent(Scenario scenario, String content) { |
| if (isEclMode(scenario)) { |
| String previous = getScriptContent(scenario); |
| if (previous != null && previous.equals(content)) { |
| return; |
| } |
| } else { |
| setTypeToEcl(scenario); |
| } |
| if (content == null /*|| content.length() == 0*/) { |
| scenario.setContent(null); |
| return; |
| } |
| Script script = CoreFactory.eINSTANCE.createScript(); |
| script.setContent(content); |
| scenario.setContent(script); |
| } |
| |
| public static void setEclContent(ITestCase scenario, String content) throws ModelException { |
| if (content == null || content.length() == 0) { |
| scenario.setContent(null); |
| return; |
| } |
| Script script = CoreFactory.eINSTANCE.createScript(); |
| script.setContent(content); |
| scenario.setContent(script); |
| } |
| |
| private static enum ScenarioMode { |
| ecl, tesla, strictEcl, strictTesla |
| } |
| |
| private static ScenarioMode getScenarioMode(Scenario scenario) { |
| String type = getScenarioType(scenario, ECL_SCENARIO_TYPE); |
| if (ECL_SCENARIO_TYPE.equals(type)) { |
| if (scenario.getTeslaContent() == null) { |
| Script script = (Script) scenario.getContent(); |
| if (script == null || script.getContent() == null || script.getContent().trim().length() == 0) |
| return ScenarioMode.ecl; |
| } else if (scenario.getTeslaContent() == null || scenario.getTeslaContent() instanceof TeslaScenario) |
| return ScenarioMode.ecl; |
| return ScenarioMode.strictEcl; |
| } else { |
| return scenario.getContent() instanceof TeslaScenario ? ScenarioMode.strictTesla : ScenarioMode.tesla; |
| } |
| } |
| |
| public static String getScriptContent(Scenario scenario) { |
| if (isEclMode(scenario)) { |
| if (hasObsoleteEclFormat(scenario) || hasUserModifications(scenario)) { |
| Script script = getEcl(scenario); |
| if (script == null) |
| return ""; |
| return script.getContent(); |
| } |
| } |
| |
| TeslaScenario tesla = getTesla(scenario); |
| if (tesla == null) |
| return ""; |
| return new EclRecorder().generateCode(tesla); |
| } |
| |
| // Suppresses default constructor, ensuring non-instantiability. |
| private Scenarios() { |
| } |
| } |
