Examples with TestCase org.cerberus.crud.entity.TestCase used on opensource projects

Example 46 with TestCase

use of org.cerberus.crud.entity.TestCase in project cerberus-source by cerberustesting.

the class ReadTestCase method findTestCaseByTest.

// </editor-fold>
private AnswerItem findTestCaseByTest(String system, String test, ApplicationContext appContext, HttpServletRequest request) throws JSONException {
    AnswerItem answer = new AnswerItem();
    JSONObject object = new JSONObject();
    testCaseService = appContext.getBean(ITestCaseService.class);
    testCaseCountryService = appContext.getBean(ITestCaseCountryService.class);
    testCaseLabelService = appContext.getBean(ITestCaseLabelService.class);
    int startPosition = Integer.valueOf(ParameterParserUtil.parseStringParam(request.getParameter("iDisplayStart"), "0"));
    int length = Integer.valueOf(ParameterParserUtil.parseStringParam(request.getParameter("iDisplayLength"), "0"));
    String searchParameter = ParameterParserUtil.parseStringParam(request.getParameter("sSearch"), "");
    String sColumns = ParameterParserUtil.parseStringParam(request.getParameter("sColumns"), "tec.test,tec.testcase,tec.application,project,ticket,description,behaviororvalueexpected,readonly,bugtrackernewurl,deploytype,mavengroupid");
    String[] columnToSort = sColumns.split(",");
    List<String> individualLike = new ArrayList(Arrays.asList(ParameterParserUtil.parseStringParam(request.getParameter("sLike"), "").split(",")));
    // Get Sorting information
    int numberOfColumnToSort = Integer.parseInt(ParameterParserUtil.parseStringParam(request.getParameter("iSortingCols"), "1"));
    int columnToSortParameter = 0;
    String sort = "asc";
    StringBuilder sortInformation = new StringBuilder();
    for (int c = 0; c < numberOfColumnToSort; c++) {
        columnToSortParameter = Integer.parseInt(ParameterParserUtil.parseStringParam(request.getParameter("iSortCol_" + c), "0"));
        sort = ParameterParserUtil.parseStringParam(request.getParameter("sSortDir_" + c), "asc");
        String columnName = columnToSort[columnToSortParameter];
        sortInformation.append(columnName).append(" ").append(sort);
        if (c != numberOfColumnToSort - 1) {
            sortInformation.append(" , ");
        }
    }
    Map<String, List<String>> individualSearch = new HashMap<String, List<String>>();
    for (int a = 0; a < columnToSort.length; a++) {
        if (null != request.getParameter("sSearch_" + a) && !request.getParameter("sSearch_" + a).isEmpty()) {
            List<String> search = new ArrayList(Arrays.asList(request.getParameter("sSearch_" + a).split(",")));
            if (individualLike.contains(columnToSort[a])) {
                individualSearch.put(columnToSort[a] + ":like", search);
            } else {
                individualSearch.put(columnToSort[a], search);
            }
        }
    }
    AnswerList testCaseList = testCaseService.readByTestByCriteria(system, test, startPosition, length, sortInformation.toString(), searchParameter, individualSearch);
    AnswerList testCaseCountryList = testCaseCountryService.readByTestTestCase(system, test, null);
    /**
     * Find the list of labels
     */
    AnswerList testCaseLabelList = testCaseLabelService.readByTestTestCase(test, null);
    LinkedHashMap<String, JSONObject> testCaseWithCountry = new LinkedHashMap();
    for (TestCaseCountry country : (List<TestCaseCountry>) testCaseCountryList.getDataList()) {
        String key = country.getTest() + "_" + country.getTestCase();
        if (testCaseWithCountry.containsKey(key)) {
            testCaseWithCountry.get(key).put(country.getCountry(), country.getCountry());
        } else {
            testCaseWithCountry.put(key, new JSONObject().put(country.getCountry(), country.getCountry()));
        }
    }
    /**
     * Iterate on the label retrieved and generate HashMap based on the key
     * Test_TestCase
     */
    LinkedHashMap<String, JSONArray> testCaseWithLabel = new LinkedHashMap();
    for (TestCaseLabel label : (List<TestCaseLabel>) testCaseLabelList.getDataList()) {
        String key = label.getTest() + "_" + label.getTestcase();
        if (testCaseWithLabel.containsKey(key)) {
            JSONObject jo = new JSONObject().put("name", label.getLabel().getLabel()).put("color", label.getLabel().getColor()).put("description", label.getLabel().getDescription());
            testCaseWithLabel.get(key).put(jo);
        } else {
            JSONObject jo = new JSONObject().put("name", label.getLabel().getLabel()).put("color", label.getLabel().getColor()).put("description", label.getLabel().getDescription());
            testCaseWithLabel.put(key, new JSONArray().put(jo));
        }
    }
    JSONArray jsonArray = new JSONArray();
    if (testCaseList.isCodeEquals(MessageEventEnum.DATA_OPERATION_OK.getCode())) {
        // the service was able to perform the query, then we should get all values
        for (TestCase testCase : (List<TestCase>) testCaseList.getDataList()) {
            String key = testCase.getTest() + "_" + testCase.getTestCase();
            JSONObject value = convertToJSONObject(testCase);
            value.put("hasPermissionsDelete", testCaseService.hasPermissionsDelete(testCase, request));
            value.put("hasPermissionsUpdate", testCaseService.hasPermissionsUpdate(testCase, request));
            value.put("hasPermissionsCreate", testCaseService.hasPermissionsCreate(testCase, request));
            value.put("countryList", testCaseWithCountry.get(key));
            value.put("labels", testCaseWithLabel.get(key));
            jsonArray.put(value);
        }
    }
    // object.put("hasPermissions", testCaseService.hasPermissions(request));
    object.put("hasPermissionsCreate", testCaseService.hasPermissionsCreate(null, request));
    object.put("contentTable", jsonArray);
    object.put("iTotalRecords", testCaseList.getTotalRows());
    object.put("iTotalDisplayRecords", testCaseList.getTotalRows());
    answer.setItem(object);
    answer.setResultMessage(testCaseList.getResultMessage());
    return answer;
}

Example 47 with TestCase

use of org.cerberus.crud.entity.TestCase in project cerberus-source by cerberustesting.

the class FactoryTestCase method create.

// private TestCase newTestCase;
@Override
public TestCase create(String test, String testCase, String origine, String refOrigine, String usrCreated, String implementer, String usrModif, String project, String ticket, String function, String application, String activeQA, String activeUAT, String activePROD, int priority, String group, String status, String description, String behavior, String howTo, String tcActive, String conditionOper, String conditionVal1, String conditionVal2, String fromBuild, String fromRev, String toBuild, String toRev, String lastExecutionStatus, String bugID, String targetBuild, String targetRev, String comment, String userAgent, String screenSize, List<TestCaseCountry> testCaseCountry, List<TestCaseCountryProperties> testCaseCountryProperties, List<TestCaseStep> testCaseStep, List<TestCaseStepBatch> testCaseStepBatch) {
    TestCase newTestCase = new TestCase();
    newTestCase.setTcActive(tcActive);
    newTestCase.setConditionOper(conditionOper);
    newTestCase.setConditionVal1(conditionVal1);
    newTestCase.setConditionVal2(conditionVal2);
    newTestCase.setApplication(application);
    newTestCase.setBugID(bugID);
    newTestCase.setComment(comment);
    newTestCase.setBehaviorOrValueExpected(behavior);
    newTestCase.setFromRev(fromRev);
    newTestCase.setFromBuild(fromBuild);
    newTestCase.setGroup(group);
    newTestCase.setHowTo(howTo);
    newTestCase.setImplementer(implementer);
    newTestCase.setOrigine(origine);
    newTestCase.setPriority(priority);
    newTestCase.setProject(project);
    newTestCase.setRefOrigine(refOrigine);
    newTestCase.setActivePROD(activePROD);
    newTestCase.setActiveQA(activeQA);
    newTestCase.setActiveUAT(activeUAT);
    newTestCase.setDescription(description);
    newTestCase.setStatus(status);
    newTestCase.setTargetRev(targetRev);
    newTestCase.setTargetBuild(targetBuild);
    newTestCase.setTest(test);
    newTestCase.setTestCase(testCase);
    newTestCase.setTicket(ticket);
    newTestCase.setToRev(toRev);
    newTestCase.setToBuild(toBuild);
    newTestCase.setUsrCreated(usrCreated);
    newTestCase.setUsrModif(usrModif);
    newTestCase.setUserAgent(userAgent);
    newTestCase.setScreenSize(screenSize);
    newTestCase.setLastExecutionStatus(lastExecutionStatus);
    newTestCase.setTestCaseCountry(testCaseCountry);
    newTestCase.setTestCaseCountryProperties(testCaseCountryProperties);
    newTestCase.setTestCaseStep(testCaseStep);
    newTestCase.setTestCaseStepBatch(testCaseStepBatch);
    newTestCase.setFunction(function);
    return newTestCase;
}

Example 48 with TestCase

use of org.cerberus.crud.entity.TestCase in project cerberus-source by cerberustesting.

the class FactoryTestCase method create.

@Override
public TestCase create(String test, String testCase, String origine, String refOrigine, String usrCreated, String implementer, String usrModif, String project, String ticket, String function, String application, String activeQA, String activeUAT, String activePROD, int priority, String group, String status, String description, String behavior, String howTo, String tcActive, String conditionOper, String conditionVal1, String conditionVal2, String fromBuild, String fromRev, String toBuild, String toRev, String lastExecutionStatus, String bugID, String targetBuild, String targetRev, String comment, String dateCreated, String userAgent, String screenSize, Timestamp dateModif, int testCaseVersion) {
    TestCase newTestCase = new TestCase();
    newTestCase.setTcActive(tcActive);
    newTestCase.setConditionOper(conditionOper);
    newTestCase.setConditionVal1(conditionVal1);
    newTestCase.setConditionVal2(conditionVal2);
    newTestCase.setApplication(application);
    newTestCase.setBugID(bugID);
    newTestCase.setComment(comment);
    newTestCase.setBehaviorOrValueExpected(behavior);
    newTestCase.setFromRev(fromRev);
    newTestCase.setFromBuild(fromBuild);
    newTestCase.setGroup(group);
    newTestCase.setHowTo(howTo);
    newTestCase.setImplementer(implementer);
    newTestCase.setLastExecutionStatus(lastExecutionStatus);
    newTestCase.setOrigine(origine);
    newTestCase.setPriority(priority);
    newTestCase.setProject(project);
    newTestCase.setRefOrigine(refOrigine);
    newTestCase.setActivePROD(activePROD);
    newTestCase.setActiveQA(activeQA);
    newTestCase.setActiveUAT(activeUAT);
    newTestCase.setDescription(description);
    newTestCase.setStatus(status);
    newTestCase.setTargetRev(targetRev);
    newTestCase.setTargetBuild(targetBuild);
    newTestCase.setTest(test);
    newTestCase.setTestCase(testCase);
    newTestCase.setTicket(ticket);
    newTestCase.setToRev(toRev);
    newTestCase.setToBuild(toBuild);
    newTestCase.setFunction(function);
    newTestCase.setUsrCreated(usrCreated);
    newTestCase.setDateCreated(dateCreated);
    newTestCase.setDateModif(dateModif);
    newTestCase.setUsrModif(usrModif);
    newTestCase.setUserAgent(userAgent);
    newTestCase.setScreenSize(screenSize);
    newTestCase.setTestCaseVersion(testCaseVersion);
    return newTestCase;
}

Example 49 with TestCase

use of org.cerberus.crud.entity.TestCase in project cerberus-source by cerberustesting.

the class ExecutionCheckService method checkTargetBuildRevision.

private boolean checkTargetBuildRevision(TestCaseExecution tCExecution) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("Checking target build");
    }
    TestCase tc = tCExecution.getTestCaseObj();
    CountryEnvParam env = tCExecution.getCountryEnvParam();
    String tcSprint = ParameterParserUtil.parseStringParam(tc.getTargetBuild(), "");
    String tcRevision = ParameterParserUtil.parseStringParam(tc.getTargetRev(), "");
    String sprint = ParameterParserUtil.parseStringParam(env.getBuild(), "");
    String revision = ParameterParserUtil.parseStringParam(env.getRevision(), "");
    int dif = -1;
    if (!tcSprint.isEmpty() && sprint != null) {
        try {
            if (sprint.isEmpty()) {
                message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_RANGE_ENVIRONMENT_BUILDREVISION_NOTDEFINED);
                return false;
            } else {
                dif = this.compareBuild(sprint, tcSprint, env.getSystem());
            }
            if (dif == 0) {
                if (!tcRevision.isEmpty() && revision != null) {
                    if (revision.isEmpty()) {
                        message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_RANGE_ENVIRONMENT_BUILDREVISION_NOTDEFINED);
                        return false;
                    } else if (this.compareRevision(revision, tcRevision, env.getSystem()) < 0) {
                        message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_TARGET_DIFFERENT);
                        return false;
                    }
                }
            } else if (dif < 0) {
                message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_TARGET_DIFFERENT);
                return false;
            }
        } catch (NumberFormatException exception) {
            message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_TARGET_WRONGFORMAT);
            return false;
        } catch (CerberusException ex) {
            message = new MessageGeneral(MessageGeneralEnum.VALIDATION_FAILED_RANGE_ENVIRONMENT_BUILDREVISION_BADLYDEFINED);
            return false;
        }
    }
    return true;
}

Example 50 with TestCase

use of org.cerberus.crud.entity.TestCase in project cerberus-source by cerberustesting.

the class ExecutionRunService method executeTestCase.

@Override
public TestCaseExecution executeTestCase(TestCaseExecution tCExecution) throws CerberusException {
    long runID = tCExecution.getId();
    String logPrefix = runID + " - ";
    /**
     * Feeding Build Rev of main Application system to
     * testcaseexecutionsysver table. Only if execution is not manual.
     */
    try {
        if (!(tCExecution.isManualURL())) {
            /**
             * Insert SystemVersion in Database
             */
            TestCaseExecutionSysVer myExeSysVer = null;
            try {
                LOG.debug(logPrefix + "Registering Main System Version.");
                myExeSysVer = factoryTestCaseExecutionSysVer.create(runID, tCExecution.getApplicationObj().getSystem(), tCExecution.getBuild(), tCExecution.getRevision());
                testCaseExecutionSysVerService.insertTestCaseExecutionSysVer(myExeSysVer);
            } catch (CerberusException ex) {
                LOG.error(logPrefix + ex.getMessage());
            }
            LOG.debug(logPrefix + "Main System Version Registered.");
            /**
             * For all Linked environment, we also keep track on the
             * build/rev information inside testcaseexecutionsysver table.
             */
            LOG.debug(logPrefix + "Registering Linked System Version.");
            try {
                List<CountryEnvLink> ceLink = null;
                ceLink = countryEnvLinkService.convert(countryEnvLinkService.readByVarious(tCExecution.getApplicationObj().getSystem(), tCExecution.getCountry(), tCExecution.getEnvironment()));
                for (CountryEnvLink myCeLink : ceLink) {
                    LOG.debug(logPrefix + "Linked environment found : " + myCeLink.getSystemLink() + myCeLink.getCountryLink() + myCeLink.getEnvironmentLink());
                    CountryEnvParam mycountEnvParam;
                    try {
                        mycountEnvParam = this.countryEnvParamService.convert(this.countryEnvParamService.readByKey(myCeLink.getSystemLink(), myCeLink.getCountryLink(), myCeLink.getEnvironmentLink()));
                        myExeSysVer = factoryTestCaseExecutionSysVer.create(runID, myCeLink.getSystemLink(), mycountEnvParam.getBuild(), mycountEnvParam.getRevision());
                        testCaseExecutionSysVerService.insertTestCaseExecutionSysVer(myExeSysVer);
                    } catch (CerberusException ex) {
                        // Referencial Integrity link between countryEnvLink and CountryEnvParam table should secure that exception to never happen.
                        LOG.error(logPrefix + ex.getMessage());
                        throw new CerberusException(ex.getMessageError());
                    }
                }
            } catch (CerberusException ex) {
                LOG.debug(logPrefix + "No Linked environment found.");
            }
            LOG.debug(logPrefix + "Linked System Version Registered.");
        }
        /**
         * Get used SeleniumCapabilities (empty if application is not GUI)
         */
        LOG.debug(logPrefix + "Getting Selenium capabitities for GUI applications.");
        if (tCExecution.getApplicationObj().getType().equalsIgnoreCase(Application.TYPE_GUI)) {
            try {
                Capabilities caps = this.seleniumServerService.getUsedCapabilities(tCExecution.getSession());
                tCExecution.setBrowserFullVersion(caps.getBrowserName() + " " + caps.getVersion() + " " + caps.getPlatform().toString());
                tCExecution.setVersion(caps.getVersion());
                tCExecution.setPlatform(caps.getPlatform().toString());
            } catch (Exception ex) {
                LOG.error(logPrefix + "Exception on selenium getting Used Capabilities :" + ex.toString());
            }
            LOG.debug(logPrefix + "Selenium capabitities loaded.");
        } else {
            // If Selenium is not needed, the selenium and browser info is set to empty.
            tCExecution.setSeleniumIP("");
            tCExecution.setSeleniumPort("");
            tCExecution.setBrowser("");
            tCExecution.setVersion("");
            tCExecution.setPlatform("");
            tCExecution.setRobotDecli("");
            LOG.debug(logPrefix + "No Selenium capabitities loaded because application not GUI : " + tCExecution.getApplicationObj().getType());
        }
        tCExecution.setRobotDecli(tCExecution.getRobotDecli().replace("%BROWSER%", tCExecution.getBrowser()));
        tCExecution.setRobotDecli(tCExecution.getRobotDecli().replace("%BROWSERVERSION%", tCExecution.getVersion()));
        tCExecution.setRobotDecli(tCExecution.getRobotDecli().replace("%PLATFORM%", tCExecution.getPlatform()));
        /**
         * Load PreTestCase information and set PreTCase to the
         * TestCaseExecution object
         */
        tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_PE_LOADINGDETAILEDDATA));
        LOG.debug(logPrefix + "Loading Pre-testcases.");
        List<TestCase> preTests = testCaseService.findTestCaseActiveByCriteria("Pre Testing", tCExecution.getTestCaseObj().getApplication(), tCExecution.getCountry());
        tCExecution.setPreTestCaseList(preTests);
        if (!(preTests == null)) {
            LOG.debug(logPrefix + "Loaded PreTest List. " + tCExecution.getPreTestCaseList().size() + " found.");
        }
        LOG.debug(logPrefix + "Pre-testcases Loaded.");
        /**
         * Load Main TestCase with Step dependencies (Actions/Control)
         */
        LOG.debug(logPrefix + "Loading all Steps information of Main testcase.");
        List<TestCaseStep> testCaseStepList;
        testCaseStepList = this.loadTestCaseService.loadTestCaseStep(tCExecution.getTestCaseObj());
        tCExecution.getTestCaseObj().setTestCaseStep(testCaseStepList);
        LOG.debug(logPrefix + "Steps information of Main testcase Loaded : " + tCExecution.getTestCaseObj().getTestCaseStep().size() + " Step(s) found.");
        /**
         * Load Pre TestCase with Step dependencies (Actions/Control)
         */
        LOG.debug(logPrefix + "Loading all Steps information (Actions & Controls) of all Pre-testcase.");
        List<TestCaseStep> preTestCaseStepList = new ArrayList<TestCaseStep>();
        List<TestCase> preTestCase = new ArrayList<TestCase>();
        for (TestCase myTCase : tCExecution.getPreTestCaseList()) {
            myTCase.setTestCaseStep(this.loadTestCaseService.loadTestCaseStep(myTCase));
            preTestCaseStepList.addAll(myTCase.getTestCaseStep());
            preTestCase.add(myTCase);
            LOG.debug(logPrefix + "Pre testcase : " + myTCase.getTest() + "-" + myTCase.getTestCase() + " Loaded With " + myTCase.getTestCaseStep().size() + " Step(s) found.");
        }
        tCExecution.setPreTestCaseList(preTestCase);
        LOG.debug(logPrefix + "All Steps information (Actions & Controls) of all Pre-testcase Loaded.");
        /**
         * Load All properties of the testcase
         */
        LOG.debug(logPrefix + "Loading all Properties.");
        List<TestCaseCountryProperties> tcProperties = new ArrayList();
        try {
            tcProperties = testCaseCountryPropertiesService.findAllWithDependencies(tCExecution.getTest(), tCExecution.getTestCase(), tCExecution.getCountry());
            tCExecution.setTestCaseCountryPropertyList(tcProperties);
        } catch (CerberusException ex) {
            LOG.warn("Exception getting all the properties : " + ex);
        }
        if (LOG.isDebugEnabled()) {
            LOG.debug(logPrefix + "All Properties Loaded. " + tcProperties.size() + " property(ies) found : " + tcProperties);
        }
        /**
         * Start Execution of the steps/Actions/controls Iterate Steps.
         * mainExecutionTestCaseStepList will contain the list of steps to
         * execute for both pretest and test. This is where we schedule the
         * execution of the steps using mainExecutionTestCaseStepList
         * object.
         */
        LOG.debug(logPrefix + "Starting the execution with step iteration.");
        List<TestCaseStep> mainExecutionTestCaseStepList;
        mainExecutionTestCaseStepList = new ArrayList<TestCaseStep>();
        mainExecutionTestCaseStepList.addAll(preTestCaseStepList);
        mainExecutionTestCaseStepList.addAll(testCaseStepList);
        /**
         * Initialize the global TestCaseExecution Data List.
         */
        // 
        tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_PE_TESTEXECUTING));
        try {
            testCaseExecutionService.updateTCExecution(tCExecution);
        } catch (CerberusException ex) {
            LOG.warn(ex);
        }
        // Websocket --> we refresh the corresponding Detail Execution pages attached to this execution.
        if (tCExecution.isCerberus_featureflipping_activatewebsocketpush()) {
            TestCaseExecutionEndPoint.getInstance().send(tCExecution, true);
        }
        // Evaluate the condition at the step level.
        AnswerItem<Boolean> conditionAnswerTc;
        AnswerItem<String> answerDecode = new AnswerItem();
        boolean conditionDecodeError = false;
        /**
         * If execution is not manual, evaluate the condition at the step
         * level
         */
        if (!tCExecution.getManualExecution().equals("Y")) {
            try {
                answerDecode = variableService.decodeStringCompletly(tCExecution.getConditionVal1(), tCExecution, null, false);
                tCExecution.setConditionVal1((String) answerDecode.getItem());
                if (!(answerDecode.isCodeStringEquals("OK"))) {
                    // If anything wrong with the decode --> we stop here with decode message in the action result.
                    tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_FA_CONDITIONDECODE).resolveDescription("MES", answerDecode.getMessageDescription()).resolveDescription("FIELD", "TestCase Condition Value1"));
                    tCExecution.setEnd(new Date().getTime());
                    LOG.debug("TestCase interupted due to decode 'TestCase Condition Value1' Error.");
                    conditionDecodeError = true;
                }
            } catch (CerberusEventException cex) {
                LOG.warn(cex);
            }
            try {
                answerDecode = variableService.decodeStringCompletly(tCExecution.getConditionVal2(), tCExecution, null, false);
                tCExecution.setConditionVal2((String) answerDecode.getItem());
                if (!(answerDecode.isCodeStringEquals("OK"))) {
                    // If anything wrong with the decode --> we stop here with decode message in the action result.
                    tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_FA_CONDITIONDECODE).resolveDescription("MES", answerDecode.getMessageDescription()).resolveDescription("FIELD", "TestCase Condition Value2"));
                    tCExecution.setEnd(new Date().getTime());
                    LOG.debug("TestCase interupted due to decode 'TestCase Condition Value2' Error.");
                    conditionDecodeError = true;
                }
            } catch (CerberusEventException cex) {
                LOG.warn(cex);
            }
        }
        if (!conditionDecodeError) {
            conditionAnswerTc = this.conditionService.evaluateCondition(tCExecution.getConditionOper(), tCExecution.getConditionVal1(), tCExecution.getConditionVal2(), tCExecution);
            boolean execute_TestCase = (boolean) conditionAnswerTc.getItem();
            if (execute_TestCase || tCExecution.getManualExecution().equals("Y")) {
                for (TestCaseStep testCaseStep : mainExecutionTestCaseStepList) {
                    // init the index of the step in case we loop.
                    int step_index = 1;
                    boolean execute_Next_Step = false;
                    TestCaseStepExecution testCaseStepExecution;
                    int maxloop = parameterService.getParameterIntegerByKey("cerberus_loopstep_max", tCExecution.getApplicationObj().getSystem(), 20);
                    do {
                        /**
                         * Start Execution of TestCaseStep
                         */
                        LOG.debug("Start execution of testcasestep");
                        long startStep = new Date().getTime();
                        /**
                         * Create and Register TestCaseStepExecution
                         */
                        MessageEvent stepMess = new MessageEvent(MessageEventEnum.STEP_PENDING).resolveDescription("STEP", String.valueOf(testCaseStep.getSort())).resolveDescription("STEPINDEX", String.valueOf(step_index));
                        testCaseStepExecution = factoryTestCaseStepExecution.create(runID, testCaseStep.getTest(), testCaseStep.getTestCase(), testCaseStep.getStep(), step_index, testCaseStep.getSort(), testCaseStep.getLoop(), testCaseStep.getConditionOper(), testCaseStep.getConditionVal1(), testCaseStep.getConditionVal2(), testCaseStep.getConditionVal1(), testCaseStep.getConditionVal2(), null, startStep, 0, startStep, 0, new BigDecimal("0"), null, stepMess, testCaseStep, tCExecution, testCaseStep.getUseStep(), testCaseStep.getUseStepTest(), testCaseStep.getUseStepTestCase(), testCaseStep.getUseStepStep(), testCaseStep.getDescription());
                        testCaseStepExecution.setLoop(testCaseStep.getLoop());
                        testCaseStepExecutionService.insertTestCaseStepExecution(testCaseStepExecution);
                        testCaseStepExecution.setExecutionResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_PE_TESTSTARTED));
                        /**
                         * We populate the TestCaseStep inside the execution
                         * List
                         */
                        tCExecution.addTestCaseStepExecutionList(testCaseStepExecution);
                        // determine if step is executed (execute_Step) and if we trigger a new step execution after (execute_Next_Step)
                        boolean execute_Step = true;
                        boolean conditionStepDecodeError = false;
                        boolean conditionStepError = false;
                        AnswerItem<Boolean> conditionAnswer = new AnswerItem<>(new MessageEvent(MessageEventEnum.CONDITIONEVAL_FAILED_UNKNOWNCONDITION));
                        if (testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_ONCEIFCONDITIONFALSE) || testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_ONCEIFCONDITIONTRUE) || testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_WHILECONDITIONFALSEDO) || testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_WHILECONDITIONTRUEDO) || testCaseStepExecution.getLoop().equals("") || step_index > 1) {
                            // Decode Conditionvalue1 and Conditionvalue2 and Evaluate the condition at the Step level.
                            try {
                                answerDecode = variableService.decodeStringCompletly(testCaseStepExecution.getConditionVal1(), tCExecution, null, false);
                                testCaseStepExecution.setConditionVal1((String) answerDecode.getItem());
                                if (!(answerDecode.isCodeStringEquals("OK"))) {
                                    testCaseStepExecution.setExecutionResultMessage(new MessageGeneral(answerDecode.getResultMessage().getMessage()));
                                    testCaseStepExecution.setStepResultMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "Step Condition Value1"));
                                    testCaseStepExecution.setReturnMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "Step Condition Value1").getDescription());
                                    testCaseStepExecution.setReturnCode(answerDecode.getResultMessage().getCodeString());
                                    testCaseStepExecution.setStopExecution(answerDecode.getResultMessage().isStopTest());
                                    testCaseStepExecution.setEnd(new Date().getTime());
                                    LOG.debug("Step interupted due to decode 'Step Condition Value1' Error.");
                                    conditionStepDecodeError = true;
                                }
                            } catch (CerberusEventException cex) {
                                LOG.warn(cex);
                            }
                            if (!conditionStepDecodeError) {
                                try {
                                    answerDecode = variableService.decodeStringCompletly(testCaseStepExecution.getConditionVal2(), tCExecution, null, false);
                                    testCaseStepExecution.setConditionVal2((String) answerDecode.getItem());
                                    if (!(answerDecode.isCodeStringEquals("OK"))) {
                                        testCaseStepExecution.setExecutionResultMessage(new MessageGeneral(answerDecode.getResultMessage().getMessage()));
                                        testCaseStepExecution.setStepResultMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "Step Condition Value2"));
                                        testCaseStepExecution.setReturnMessage(answerDecode.getResultMessage().resolveDescription("FIELD", "Step Condition Value2").getDescription());
                                        testCaseStepExecution.setReturnCode(answerDecode.getResultMessage().getCodeString());
                                        testCaseStepExecution.setStopExecution(answerDecode.getResultMessage().isStopTest());
                                        testCaseStepExecution.setEnd(new Date().getTime());
                                        LOG.debug("Step interupted due to decode 'Step Condition Value2' Error.");
                                        conditionStepDecodeError = true;
                                    }
                                } catch (CerberusEventException cex) {
                                    LOG.warn(cex);
                                }
                            }
                            if (!(conditionStepDecodeError)) {
                                conditionAnswer = this.conditionService.evaluateCondition(testCaseStepExecution.getConditionOper(), testCaseStepExecution.getConditionVal1(), testCaseStepExecution.getConditionVal2(), tCExecution);
                                execute_Step = (boolean) conditionAnswer.getItem();
                                if (conditionAnswer.getResultMessage().getMessage().getCodeString().equals("PE")) {
                                    // There were no error when performing the condition evaluation.
                                    switch(testCaseStepExecution.getLoop()) {
                                        case TestCaseStep.LOOP_ONCEIFCONDITIONFALSE:
                                            execute_Step = !execute_Step;
                                            execute_Next_Step = false;
                                            break;
                                        case TestCaseStep.LOOP_ONCEIFCONDITIONTRUE:
                                        case "":
                                            execute_Next_Step = false;
                                            break;
                                        case TestCaseStep.LOOP_WHILECONDITIONFALSEDO:
                                        case TestCaseStep.LOOP_DOWHILECONDITIONFALSE:
                                            execute_Step = !execute_Step;
                                            execute_Next_Step = execute_Step;
                                            break;
                                        case TestCaseStep.LOOP_WHILECONDITIONTRUEDO:
                                        case TestCaseStep.LOOP_DOWHILECONDITIONTRUE:
                                            execute_Next_Step = execute_Step;
                                            break;
                                        default:
                                            execute_Next_Step = false;
                                    }
                                } else {
                                    // Error when performing the condition evaluation. We force no execution (false)
                                    MessageGeneral mes = new MessageGeneral(MessageGeneralEnum.EXECUTION_FA_CONDITION);
                                    mes.setDescription(mes.getDescription().replace("%AREA%", "step ").replace("%COND%", testCaseStepExecution.getConditionOper()).replace("%MES%", conditionAnswer.getResultMessage().getDescription()));
                                    tCExecution.setResultMessage(mes);
                                    testCaseStepExecution.setExecutionResultMessage(mes);
                                    testCaseStepExecution.setStepResultMessage(new MessageEvent(MessageEventEnum.CONDITION_TESTCASESTEP_FAILED).resolveDescription("AREA", "").resolveDescription("COND", testCaseStepExecution.getConditionOper()).resolveDescription("MESSAGE", conditionAnswer.getResultMessage().getDescription()));
                                    testCaseStepExecution.setEnd(new Date().getTime());
                                    LOG.debug("Step interupted due to condition error.");
                                    conditionStepError = true;
                                    execute_Next_Step = false;
                                    execute_Step = false;
                                }
                            } else {
                                // If anything wrong with the decode --> we stop here with decode message in the action result.
                                tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_FA_CONDITIONDECODE).resolveDescription("AREA", "Step ").resolveDescription("MES", answerDecode.getMessageDescription()));
                                tCExecution.setEnd(new Date().getTime());
                                LOG.debug("TestCase interupted due to decode Condition Error.");
                                // There was an error on decode so we stop everything.
                                execute_Next_Step = false;
                                execute_Step = false;
                            }
                        } else if (testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_DOWHILECONDITIONFALSE) || testCaseStepExecution.getLoop().equals(TestCaseStep.LOOP_DOWHILECONDITIONTRUE)) {
                            // First Step execution for LOOP_DOWHILECONDITIONTRUE and LOOP_DOWHILECONDITIONFALSE --> We force the step execution and activate the next step execution.
                            execute_Step = true;
                            execute_Next_Step = true;
                        } else {
                            // First Step execution for Unknown Loop --> We force the step execution only once (default behaviour).
                            execute_Step = true;
                            execute_Next_Step = false;
                            conditionAnswer.setResultMessage(new MessageEvent(MessageEventEnum.CONDITIONEVAL_FAILED_UNKNOWNCONDITION));
                        }
                        /**
                         * Execute Step
                         */
                        LOG.debug(logPrefix + "Executing step : " + testCaseStepExecution.getTest() + " - " + testCaseStepExecution.getTestCase() + " - Step " + testCaseStepExecution.getStep() + " - Index " + testCaseStepExecution.getStep());
                        if (execute_Step) {
                            /**
                             * We execute the step
                             */
                            testCaseStepExecution = this.executeStep(testCaseStepExecution, tCExecution);
                            /**
                             * Updating Execution Result Message only if
                             * execution result message of the step is not
                             * PE or OK.
                             */
                            if ((!(testCaseStepExecution.getExecutionResultMessage().equals(new MessageGeneral(MessageGeneralEnum.EXECUTION_PE_TESTSTARTED)))) && (!(testCaseStepExecution.getExecutionResultMessage().equals(new MessageGeneral(MessageGeneralEnum.EXECUTION_OK))))) {
                                tCExecution.setResultMessage(testCaseStepExecution.getExecutionResultMessage());
                            }
                            if (testCaseStepExecution.getStepResultMessage().equals(new MessageEvent(MessageEventEnum.STEP_PENDING))) {
                                testCaseStepExecution.setStepResultMessage(new MessageEvent(MessageEventEnum.STEP_SUCCESS));
                            }
                            testCaseStepExecutionService.updateTestCaseStepExecution(testCaseStepExecution);
                            if (testCaseStepExecution.isStopExecution()) {
                                break;
                            }
                        } else // We don't execute the step and record a generic execution.
                        if ((!conditionStepDecodeError) && (!conditionStepError)) {
                            /**
                             * Register Step in database
                             */
                            LOG.debug("Registering Step : " + testCaseStepExecution.getStep());
                            // We change the Step message only if the Step is not executed due to condition.
                            MessageEvent stepMes = new MessageEvent(MessageEventEnum.CONDITION_TESTCASESTEP_NOTEXECUTED);
                            testCaseStepExecution.setStepResultMessage(stepMes);
                            testCaseStepExecution.setReturnMessage(testCaseStepExecution.getReturnMessage().replace("%COND%", testCaseStepExecution.getConditionOper()).replace("%LOOP%", testCaseStepExecution.getLoop()).replace("%MESSAGE%", conditionAnswer.getResultMessage().getDescription()));
                            testCaseStepExecution.setEnd(new Date().getTime());
                            this.testCaseStepExecutionService.updateTestCaseStepExecution(testCaseStepExecution);
                            LOG.debug("Registered Step");
                        } else {
                            // Not executed because decode error or failed condition.
                            testCaseStepExecution.setEnd(new Date().getTime());
                            testCaseStepExecution.setStopExecution(true);
                            this.testCaseStepExecutionService.updateTestCaseStepExecution(testCaseStepExecution);
                            LOG.debug("Registered Step");
                        }
                        /**
                         * Log TestCaseStepExecution
                         */
                        if (tCExecution.getVerbose() > 0) {
                            LOG.info(testCaseStepExecution.toJson(false, true));
                        }
                        // Websocket --> we refresh the corresponding Detail Execution pages attached to this execution.
                        if (tCExecution.isCerberus_featureflipping_activatewebsocketpush()) {
                            TestCaseExecutionEndPoint.getInstance().send(tCExecution, false);
                        }
                        step_index++;
                    } while (execute_Next_Step && step_index <= maxloop);
                    if (testCaseStepExecution.isStopExecution()) {
                        break;
                    }
                }
                /**
                 * If at that time the execution is still PE, we move it to
                 * OK. It means that no issue were met.
                 */
                if ((tCExecution.getResultMessage() == null) || (tCExecution.getResultMessage().equals(new MessageGeneral(MessageGeneralEnum.EXECUTION_PE_TESTSTARTED)))) {
                    tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_OK));
                }
                /**
                 * We record Selenium log at the end of the execution.
                 */
                try {
                    tCExecution.addFileList(recorderService.recordSeleniumLog(tCExecution));
                } catch (Exception ex) {
                    LOG.error(logPrefix + "Exception Getting Selenium Logs " + tCExecution.getId() + " Exception :" + ex.toString());
                }
            } else {
                // We don't execute the testcase linked with condition.
                MessageGeneral mes;
                /**
                 * Update Execution status from condition
                 */
                if (conditionAnswerTc.getResultMessage().getMessage().getCodeString().equals("PE")) {
                    mes = new MessageGeneral(MessageGeneralEnum.EXECUTION_NA_CONDITION);
                } else {
                    mes = new MessageGeneral(MessageGeneralEnum.EXECUTION_FA_CONDITION);
                }
                mes.setDescription(mes.getDescription().replace("%COND%", tCExecution.getConditionOper()).replace("%MES%", conditionAnswerTc.getResultMessage().getDescription()));
                tCExecution.setResultMessage(mes);
            }
        }
    } catch (Exception ex) {
        /**
         * If an exception is found, set the execution to FA and print the
         * exception
         */
        tCExecution.setResultMessage(new MessageGeneral(MessageGeneralEnum.EXECUTION_FA));
        tCExecution.setControlMessage(tCExecution.getControlMessage() + " Exception: " + ex);
        LOG.error(logPrefix + "Exception found Executing Test " + tCExecution.getId() + " Exception :" + ex.toString());
    } finally {
        /**
         * We stop the server session here (selenium for ex.).
         */
        try {
            tCExecution = this.stopTestCase(tCExecution);
        } catch (Exception ex) {
            LOG.error(logPrefix + "Exception Stopping Test " + tCExecution.getId() + " Exception :" + ex.toString());
        }
        /**
         * Log Execution
         */
        LOG.info(tCExecution.toJson(false));
        /**
         * Clean memory
         */
        try {
            executionUUID.removeExecutionUUID(tCExecution.getExecutionUUID());
            LOG.debug("Clean ExecutionUUID");
        } catch (Exception ex) {
            LOG.error("Exception cleaning Memory: " + ex.toString());
        }
        /**
         * Log execution is finished
         */
        LOG.info("Execution Finished : UUID=" + tCExecution.getExecutionUUID() + "__ID=" + tCExecution.getId() + "__RC=" + tCExecution.getControlStatus() + "__" + "TestName=" + tCExecution.getEnvironment() + "." + tCExecution.getCountry() + "." + tCExecution.getBuild() + "." + tCExecution.getRevision() + "." + tCExecution.getTest() + "_" + tCExecution.getTestCase() + "_" + tCExecution.getTestCaseObj().getDescription().replace(".", ""));
        /**
         * Updating queue to done status only for execution from queue
         */
        if (tCExecution.getQueueID() != 0) {
            executionQueueService.updateToDone(tCExecution.getQueueID(), "", runID);
        }
        /**
         * Retry management, in case the result is not (OK or NE), we
         * execute the job again reducing the retry to 1.
         */
        if (tCExecution.getNumberOfRetries() > 0 && !tCExecution.getResultMessage().getCodeString().equals("OK") && !tCExecution.getResultMessage().getCodeString().equals("NE")) {
            TestCaseExecutionQueue newExeQueue = new TestCaseExecutionQueue();
            if (tCExecution.getQueueID() > 0) {
                // If QueueId exist, we try to get the original execution queue.
                try {
                    newExeQueue = executionQueueService.convert(executionQueueService.readByKey(tCExecution.getQueueID()));
                } catch (Exception e) {
                    // Unfortunatly the execution no longuer exist so we pick initial value.
                    newExeQueue = tCExecution.getTestCaseExecutionQueue();
                }
            } else {
                // Initial Execution does not come from the queue so we pick the value created at the beginning of the execution.
                newExeQueue = tCExecution.getTestCaseExecutionQueue();
            }
            // Forcing init value for that new queue execution : exeid=0, no debugflag and State = QUEUED
            int newRetry = tCExecution.getNumberOfRetries() - 1;
            newExeQueue.setId(0);
            newExeQueue.setDebugFlag("N");
            if (newRetry <= 0) {
                newExeQueue.setComment("Added from Retry. Last attempt to go.");
            } else {
                newExeQueue.setComment("Added from Retry. Still " + newRetry + " attempt(s) to go.");
            }
            newExeQueue.setState(TestCaseExecutionQueue.State.QUEUED);
            newExeQueue.setRetries(newRetry);
            // Insert execution to the Queue.
            executionQueueService.create(newExeQueue);
        }
        /**
         * After every execution finished, <br>
         * if the execution has a tag that has a campaign associated  <br>
         * and no more executions are in the queue, <br>
         * we trigger : <br>
         * 1/ The update of the EndExeQueue of the tag <br>
         * 2/ We notify the Distribution List with execution report status
         */
        try {
            if (!StringUtil.isNullOrEmpty(tCExecution.getTag())) {
                Tag currentTag = tagService.convert(tagService.readByKey(tCExecution.getTag()));
                if ((currentTag != null)) {
                    if (currentTag.getDateEndQueue().before(Timestamp.valueOf("1980-01-01 01:01:01.000000001"))) {
                        AnswerList answerListQueue = new AnswerList();
                        answerListQueue = executionQueueService.readQueueOpen(tCExecution.getTag());
                        if (answerListQueue.isCodeEquals(MessageEventEnum.DATA_OPERATION_OK.getCode()) && (answerListQueue.getDataList().isEmpty())) {
                            LOG.debug("No More executions in (queue) on tag : " + tCExecution.getTag() + " - " + answerListQueue.getDataList().size() + " " + answerListQueue.getMessageCodeString() + " - ");
                            tagService.updateDateEndQueue(tCExecution.getTag(), new Timestamp(new Date().getTime()));
                            if (!StringUtil.isNullOrEmpty(currentTag.getCampaign())) {
                                // We get the campaig here and potencially send the notification.
                                emailService.generateAndSendNotifyEndTagExecution(tCExecution.getTag(), currentTag.getCampaign());
                            }
                        } else {
                            LOG.debug("Still executions in queue on tag : " + tCExecution.getTag() + " - " + answerListQueue.getDataList().size() + " " + answerListQueue.getMessageCodeString());
                        }
                    } else {
                        LOG.debug("Tag is already flaged with recent timstamp. " + currentTag.getDateEndQueue());
                    }
                }
            }
        } catch (Exception e) {
            LOG.error(e);
        }
        // 
        // After every execution finished we try to trigger more from the queue;-).
        executionThreadPoolService.executeNextInQueueAsynchroneously(false);
    }
    return tCExecution;
}