package br.mia.test.model.algoritmo;

 import java.io.FileNotFoundException;

 import java.io.IOException;

 import java.io.UnsupportedEncodingException;

 import java.sql.SQLException;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import org.apache.log4j.Logger;

 import br.mia.test.controler.ControladorErro;

 import br.mia.test.model.CasoUso;

 import br.mia.test.model.CodeFactorySelenium;

 import br.mia.test.model.CodeFactoryXDE;

 import br.mia.test.model.Filtro;

 import br.mia.test.model.Fluxo;

 import br.mia.test.model.ItemData;

 import br.mia.test.model.Link;

 import br.mia.test.model.Projeto;

 import br.mia.test.model.RegraNegocio;

 import br.mia.test.model.RegraNegocioStep;

 import br.mia.test.model.RuleDelete;

 import br.mia.test.model.Step;

 import br.mia.test.model.TestDataValor;

 import br.mia.test.testcase.CasoTesteStep;

 import br.mia.test.testcase.CasosTeste;

 import br.mia.test.testcase.CasosTesteCodigo;

 import br.mia.test.testcase.DadosTeste;

 import br.mia.test.util.Util;

 import com.lowagie.text.html.HtmlEncoder;

 /***

  * Algoritmo de gera��o dos casos de teste

  *

  * @author 74397176353

  *

  */

 public class Algoritmo

 {

     private StringBuffer filtrosAplicados;

     public StringBuffer getFiltrosAplicados() {

         return filtrosAplicados;

     }

     public void setFiltrosAplicados(StringBuffer filtrosAplicados) {

         this.filtrosAplicados = filtrosAplicados;

     }

     private ArrayList<TestDataValor> valoresTeste = new ArrayList<TestDataValor>();

     private HashMap<String, RegraNegocio> regrasCobertas;

     boolean adicionarCasoTeste = true;

     private ArrayList<CasosTeste> casosDeTeste = new ArrayList<CasosTeste>();

     private ArrayList<CasosTeste> casosDeTesteData = new ArrayList<CasosTeste>();

     private static HashMap<String, Fluxo> flows = new HashMap<String, Fluxo>();

     public HashMap<String, RegraNegocio> getRegrasCobertas() {

         return regrasCobertas;

     }

     public void setRegrasCobertas(HashMap<String, RegraNegocio> regrasCobertas) {

         this.regrasCobertas = regrasCobertas;

     }

     /***

      * Limpa ids de todos os objetos da arvore setando os mesmos para zero

      *

      * @param useCase

      */

     public void limpaArvore(CasoUso useCase) {

         for (Object element : useCase.getFlows()) {

             Fluxo flow = (Fluxo) element;

             for (Object element1 : flow.getSteps()) {

                 Step step = (Step) element1;

                 step.setCoberto(false);

                 step.setNumberOfExecution(0);

             }

             flows.put(flow.getName(), flow);

         }

     }

     /***

      * Aplicando dados de teste a caso de teste

      *

      * @param dados

      * @param testCase

      * @param posicao

      * @param novoCasoAux

      * @param nivel

      * @param passo

      * @param descricao

      * @param useCase

      * @param step

      * @param data

      * @throws InstantiationException

      * @throws IllegalAccessException

      * @throws ClassNotFoundException

      * @throws SQLException

      * @throws IOException

      */

     public void applyDataValue(ArrayList<ItemData> dados, CasosTeste testCase,

             int posicao, CasosTeste novoCasoAux, int nivel, String passo,

             String descricao, CasoUso useCase, Step step, DadosTeste data)

             throws InstantiationException, IllegalAccessException,

             ClassNotFoundException, SQLException, IOException {

         ItemData item = (ItemData) dados.get(nivel);

         HashMap<Object, Object> mapaAntigo = new HashMap<Object, Object>();

         mapaAntigo.putAll(novoCasoAux.getClasses());

         String passoOriginal;

         for (Object object : item.getItemFilhos()) {

             novoCasoAux.setClasses(new HashMap<Object, Object>());

             novoCasoAux.getClasses().putAll(mapaAntigo);

             TestDataValor valor = (TestDataValor) object;

             Logger logger=Util.getLogger();

             logger.info("Aplicando Valor :"+useCase.getName()+":"+step.getFluxo().getName()+":"+valor.getValor());

             if (!(novoCasoAux.isCoberturaFiltro())) {

                 if ((!(valor.isValid())) && (!(valor.isValorEsperado()))) {

                     novoCasoAux.setValid(false);

                     novoCasoAux.setCoberturaFiltro(true);

                     logger.info("Aplica Valores :"+useCase.getName()+":"+step.getFluxo().getName()+":"+valor.getValor());

                 } else {

                     novoCasoAux.setValid(true);

                 }

             }

             if ((valor.getResultadoEsperado() != null)

                     && (valor.getResultadoEsperado().toString().length() > 0)) {

                 String valorEsperado = " ("

                         + valor.getResultadoEsperado().toString() + " )";

                 CasoUso.getResultadosValidos().put(

                         item.getTestData().getName(), valorEsperado);

             }

             passoOriginal = passo;

             String[] valores = valor.getValor().toString().split("\n");

             if ((valor.getClasse() != null) && (valor.getClasse().length() > 0)) {

                 if (!(novoCasoAux.getClasses().containsKey(valor.getClasse()

                         .toString()))) {

                     novoCasoAux.getClasses().put(valor.getClasse().toString(),

                             valor.getClasse());

                 }

             }

             if ((nivel < dados.size() - 1) && (testCase.isNormal())) {

                 applyDataValue(dados, testCase, posicao, novoCasoAux,

                         nivel + 1, passo, descricao, useCase, step, data);

             } else {

                 CasosTeste novoCaso = new CasosTeste();

                 novoCaso.setValid(novoCasoAux.isValid());

                 novoCaso.setCoberturaFiltro(novoCasoAux.isCoberturaFiltro());

                 HashMap<Object, Object> novaClasse = new HashMap<Object, Object>();

                 novaClasse.putAll(novoCasoAux.getClasses());

                 novoCaso.setClasses(novaClasse);

                 if (!(valor.isValid())) {

                     if (testCase.isNormal()) {

                         novoCaso.setNormal(false);

                         novoCaso.setInvalidData(item.getTestData());

                     }

                 } else {

                     novoCaso.setNormal(novoCasoAux.isNormal());

                     novoCaso.setInvalidData(novoCasoAux.getInvalidData());

                 }

                 novoCaso.setNumeroCasosTeste(novoCasoAux.getNumeroCasosTeste());

                 novoCaso.getPassos().addAll(novoCasoAux.getPassos());

                 novoCaso.getFlows().addAll(novoCasoAux.getFlows());

                 novoCaso.setEntradas(novoCasoAux.getEntradas());

                 novoCaso.setSaidasEsperadas(novoCasoAux.getSaidasEsperadas());

                 novoCaso.getResultadoEsperado().append(

                         novoCasoAux.getResultadoEsperado());

                 for (int i = 0; i <= valores.length - 1; i++) {

                     Step novoStep = new Step();

                     String novoPasso = passo.replaceAll(item.getCard(),

                             valores[i]);

                     if ((valor.getResultadoEsperado() != null)

                             && (valor.getResultadoEsperado().toString()

                                     .length() > 0)) {

                         if (novoCaso.getSaidasEsperadas() == null) {

                             novoCaso.setSaidasEsperadas("");

                         }

                         if (!(novoCaso.getSaidasEsperadas().contains(valor

                                 .getResultadoEsperado().toString()))) {

                             novoCaso.setSaidasEsperadas(valor

                                     .getResultadoEsperado().toString());

                         }

                     }

                     if (novoCaso.getEntradas() == null) {

                         novoCaso.setEntradas("");

                     }

                     if (!(novoCaso.getEntradas()

                             .contains(valores[i].toString()))) {

                         novoCaso.setEntradas(novoCaso.getEntradas() + " "

                                 + valores[i].toString());

                     }

                     novoStep.setDescricaoOriginal(passoOriginal);

                     novoStep.setDescricao(novoPasso);

                     novoStep.setDatas(step.getDatas());

                     CasoTesteStep casoTesteStep = new CasoTesteStep();

                     casoTesteStep.setStep(novoStep);

                     novoCaso.getPassos().add(casoTesteStep);

                 }

                 if (testCase.getNumeroCasosTeste() > testCase

                         .getNumeroMaximoCasosTeste()) {

                     return;

                 }

                 applyData(testCase, posicao + 1, novoCaso, useCase,

                         adicionarCasoTeste);

             }

             passo = descricao;

         }

     }

     public void applyCode(CasosTeste testCase, int posicao, String linguagem)

             throws InstantiationException, IllegalAccessException,

             ClassNotFoundException, SQLException, FileNotFoundException {

         while (posicao <= testCase.getPassos().size() - 1) {

             Step step = (Step) testCase.getPassos().get(posicao).getStep();

             if (step.getDatas().size() <= 0) {

                 String code = "";

                 if (linguagem.equals("XDE")) {

                     code = CodeFactoryXDE.gera(step.getTipoObjeto(), step

                             .getPalavraChave(), "", step.getDescricao());

                 }

                 if (linguagem.equals("Selenium")) {

                     code = CodeFactorySelenium.gera(step.getTipoObjeto(), step

                             .getPalavraChave(), "", step.getDescricao());

                 }

                 String descricao = code;

                 step.setDescricao(descricao);

             } else {

                 String wildCard = "";

                 for (int i = 0; i <= step.getDatas().size() - 1; i++) {

                     DadosTeste testData = (DadosTeste) step.getDatas().get(i);

                     wildCard += testData.getCard() + " ";

                 }

                 String code = CodeFactoryXDE.gera(step.getTipoObjeto(), step

                         .getPalavraChave(), wildCard, step.getDescricao());

                 String descricao = code;

                 step.setDescricao(descricao);

             }

             posicao++;

         }

     }

     /***

      * Aplica dados de testes a caso de teste e adiciona o novoCasodeTeste a

      * variavel local casosdeteste

      *

      * @param testCase

      * @param posicao

      * @param novoCasodeTeste

      * @param useCase

      * @param adicionar

      * @throws InstantiationException

      * @throws IllegalAccessException

      * @throws ClassNotFoundException

      * @throws SQLException

      * @throws IOException

      */

     public void applyData(CasosTeste testCase, int posicao,

             CasosTeste novoCasodeTeste, CasoUso useCase, boolean adicionar)

             throws InstantiationException, IllegalAccessException,

             ClassNotFoundException, SQLException, IOException {

         novoCasodeTeste.getFlows().addAll(testCase.getFlows());

         DadosTeste testData = null;

         while (posicao <= testCase.getPassos().size() - 1) {

             Step step = (Step) testCase.getPassos().get(posicao).getStep();

             String descricao = step.getDescricao();

             if (step.getDatas().size() > 0) {

                 ArrayList<ItemData> dados = new ArrayList<ItemData>();

                 for (int i = 0; i <= step.getDatas().size() - 1; i++) {

                     ArrayList<TestDataValor> array = new ArrayList<TestDataValor>();

                     testData = (DadosTeste) step.getDatas().get(i);

                     boolean isResult = false;

                     List<TestDataValor> valores = null;

                     if (testData.isResult()) {

                         String resultado = "";

                         if (CasoUso.getResultadosValidos().containsKey(

                                 testData.getName().replace("vp", ""))) {

                             resultado = CasoUso.getResultadosValidos().get(

                                     testData.getName().replace("vp", ""))

                                     .toString();

                             isResult = true;

                             TestDataValor valorEsperado = new TestDataValor();

                             valorEsperado.setDadoteste(testData);

                             valorEsperado.setValor(resultado);

                             valorEsperado.setValorEsperado(true);

                             valorEsperado.setResultadoEsperado(resultado);

                             array.add(valorEsperado);

                         }

                     }

                     ItemData item = new ItemData();

                     item.setTestData(testData);

                     item.setCard(testData.getCard());

                     if (isResult) {

                         item.getItemFilhos().addAll(array);

                     } else {

                         item.getItemFilhos().addAll(testData.getValues());

                     }

                     dados.add(item);

                 }

                 boolean apply = true;

                 List<Filtro> filtros = step.getFiltros();

                 for (Filtro filtro : filtros) {

                     if (filtro.getTipoFiltro() == 1) {

                         if (!(novoCasodeTeste.isValid())) {

                             adicionar = false;

                             apply = false;

                             break;

                         }

                     }

                     if (filtro.getTipoFiltro() == 0) {

                         if ((novoCasodeTeste.isValid())) {

                             adicionar = false;

                             apply = false;

                             break;

                         }

                     }

                     if (filtro.getTipoFiltro() == 2) {

                         if (filtro.getClasse() != null) {

                             if (!(novoCasodeTeste.getClasses()

                                     .containsKey(filtro.getClasse().toString()))) {

                                 adicionar = false;

                                 apply = false;

                                 Util.getLogger().info("Filtro:"+useCase.getName()+":"+step.getFluxo().getName()+"N�o encontado classe "

                                                 + filtro.getClasse()

                                                 + "  no passo "

                                                 + step.getDescricao()

                                                 + " classes encontradas neste passo "

                                                 + novoCasodeTeste.getClasses()

                                                         .values()+" \n");

                                 break;

                             } else {

                                 adicionar = true;

                                 apply = true;

                                 break;

                             }

                         }

                     }

                 }

                 if (apply) {

                     this.applyDataValue(dados, testCase, posicao,

                             novoCasodeTeste, 0, descricao, descricao, useCase,

                             step, testData);

                 }

                 adicionar = false;

                 break;

             } else {

                 boolean apply = true;

                 for (Filtro filtro : step.getFiltros()) {

                     if (filtro.getTipoFiltro() == 1) {

                         if (!(novoCasodeTeste.isValid())) {

                             adicionar = false;

                             apply = false;

                             break;

                         }

                     }

                     if (filtro.getTipoFiltro() == 0) {

                         if ((novoCasodeTeste.isValid())) {

                             adicionar = false;

                             apply = false;

                             break;

                         }

                     }

                     if (filtro.getTipoFiltro() == 2) {

                         if (filtro.getClasse() != null) {

                             if (!(novoCasodeTeste.getClasses()

                                     .containsKey(filtro.getClasse().toString()))) {

                                 adicionar = false;

                                 apply = false;

                                 Util.getLogger().info("Filtro:"+useCase.getName()+":"+step.getFluxo().getName()+"N�o encontado classe "

                                         + filtro.getClasse()

                                         + "  no passo "

                                         + step.getDescricao()

                                         + " classes encontradas neste passo "

                                         + novoCasodeTeste.getClasses()

                                                 .values()+" \n");

                                 break;

                             } else {

                                 adicionar = true;

                                 apply = true;

                                 break;

                             }

                         }

                     }

                 }

                 if (!(apply)) {

                     break;

                 }

                 CasoTesteStep casoTesteStep = new CasoTesteStep();

                 casoTesteStep.setStep(step);

                 novoCasodeTeste.getPassos().add(casoTesteStep);

             }

             for (Filtro filtro : step.getFiltros()) {

                 if (filtro.getTipoFiltro() == 1) {

                     if (!(novoCasodeTeste.isValid())) {

                         adicionar = false;

                         break;

                     }

                 }

                 if (filtro.getTipoFiltro() == 0) {

                     if ((novoCasodeTeste.isValid())) {

                         adicionar = false;

                         break;

                     }

                 }

                 if (filtro.getTipoFiltro() == 2) {

                     if (filtro.getClasse() != null) {

                         if (!(novoCasodeTeste.getClasses().containsKey(filtro

                                 .getClasse().toString()))) {

                             adicionar = false;

                             break;

                         } else {

                             adicionar = true;

                             break;

                         }

                     }

                 }

             }

             posicao++;

         }

         if (adicionar) {

             testCase.setNumeroCasosTeste(testCase.getNumeroCasosTeste() + 1);

             Util.getLogger().info("CASOTESTE:Adicionado Caso de Teste dos Fluxos "+novoCasodeTeste.getFlows()+"\n");

             Util.getLogger().info("CASOTESTE:Adicionado Caso de Teste das Classes "+novoCasodeTeste.getClasses()+"\n");

             this.casosDeTesteData.add(novoCasodeTeste);

         }

     }

     /***

      * Realiza verifica��o dos filtros linkados aque passo

      *

      * @param step Passo de Caso de Teste

      * @param testCase Caso de teste

      * @return

      */

     public boolean verificaFiltro(Step step, CasosTeste testCase) {

         boolean para = false;

         for (Filtro filtro : step.getFiltros()) {

             if (filtro.getTipoFiltro() == 1) {

                 if (!(testCase.isValid())) {

                     adicionarCasoTeste = false;

                     para = true;

                 }

             }

             if (filtro.getTipoFiltro() == 0) {

                 if ((testCase.isValid())) {

                     adicionarCasoTeste = false;

                     para = true;

                 }

             }

             if (filtro.getTipoFiltro() == 2) {

                 if (step.getClasse() != null) {

                     if (!(testCase.getClasses().containsKey(step.getClasse()

                             .toString()))) {

                         adicionarCasoTeste = false;

                         para = true;

                     } else {

                         adicionarCasoTeste = true;

                         para = false;

                         break;

                     }

                 }

             }

         }

         return para;

     }

     public void retornaCenarios(Fluxo flow, int number, CasosTeste casoTeste,

             int points, CasoUso useCase) {

         try {

             if (!(Algoritmo.flows.containsKey(flow.getName()))) {

                 Algoritmo.flows.put(flow.getName(), flow);

             }

             casoTeste.getFlows().add(flow);

             while (number <= flow.getSteps().size() - 1) {

                 Step step = (Step) ((Fluxo) Algoritmo.flows.get(flow.getName()))

                         .getSteps().get(number);

                 CasoTesteStep casoTesteStep = new CasoTesteStep();

                 casoTesteStep.setStep(step);

                 casoTeste.getPassos().add(casoTesteStep);

                 step.setCoberto(true);

                 int numeroExecucoes = step.getNumberOfExecution();

                 if (numeroExecucoes > (useCase.getFlows().size() * 2)) {

                     break;

                 }

                 step.setNumberOfExecution(numeroExecucoes + 1);

                 if (step.getRegras().size() > 0) {

                     for (int i = 0; i <= step.getRegras().size() - 1; i++) {

                         RegraNegocio regra = ((RegraNegocio) step.getRegras()

                                 .get(i));

                         if ((!(this.regrasCobertas.containsKey(regra.getName())))

                                 || (regra.isReuse())) {

                             for (RegraNegocioStep stepRegra : regra.getSteps()) {

                                 CasoTesteStep casoStep = new CasoTesteStep();

                                 casoStep.setStep(stepRegra.toStep());

                                 casoTeste.getPassos().add(casoStep);

                             }

                             if (!(regra.isReuse())) {

                                 this.regrasCobertas.put(regra.getName(), regra);

                             }

                         }

                     }

                 }

                 if (step.getLinks().size() > 0) {

                     for (int i = 0; i <= step.getLinks().size() - 1; i++) {

                         Link link1 = ((Link) step.getLinks().get(i));

                         if (link1.getFlow() != null) {

                             if (!(Algoritmo.flows.containsKey(link1.getFlow()

                                     .getName()))) {

                                 Algoritmo.flows.put(link1.getFlow().getName(),

                                         link1.getFlow());

                             }

                             if (((Fluxo) (Algoritmo.flows.get(link1.getFlow()

                                     .getName()))).steps.size() == 0) {

                                 Algoritmo.flows.put(link1.getFlow().getName(),

                                         link1.getFlow());

                             }

                             if (Fluxo.getStepNumber(((Fluxo) Algoritmo.flows

                                     .get(link1.getFlow().getName()))) != Fluxo

                                     .getStepNumberCover(((Fluxo) Algoritmo.flows

                                             .get(link1.getFlow().getName())))) {

                                 CasosTeste casoTeste1 = new CasosTeste();

                                 casoTeste1.getFlows().addAll(

                                         casoTeste.getFlows());

                                 casoTeste1.getPassos().addAll(0,

                                         casoTeste.getPassos());

                                 RuleDelete ruleDelete = new RuleDelete();

                                 ruleDelete.ruleDelete(casoTeste1, this

                                         .getRegrasCobertas());

                                 retornaCenarios(((Fluxo) Algoritmo.flows

                                         .get(link1.getFlow().getName())), link1

                                         .getStepNumber(), casoTeste1, points,

                                         useCase);

                             }

                         }

                     }

                 }

                 number++;

             }

             casoTeste.setNumeroMaximoCasosTeste(flow.getNumeroMaximo());

             casosDeTeste.add(casoTeste);

         } catch (StackOverflowError e) {

             casoTeste.setNumeroMaximoCasosTeste(flow.getNumeroMaximo());

             casosDeTeste.add(casoTeste);

         }

     }

     public Algoritmo() {

         this.regrasCobertas = new HashMap<String, RegraNegocio>();

         this.filtrosAplicados = new StringBuffer();

     }

     public String mostra() {

         StringBuffer buffer = new StringBuffer();

         for (int i = 0; i <= this.casosDeTesteData.size() - 1; i++) {

             buffer.append(this.casosDeTesteData.get(i));

         }

         return buffer.toString();

     }

     public String mostraCode(CasoUso useCase,

             ArrayList<CasosTesteCodigo> casosTeste, String linguagem) {

         StringBuffer buffer = new StringBuffer();

         for (int i = 0; i <= casosTeste.size() - 1; i++) {

             CasosTesteCodigo testCase = (CasosTesteCodigo) casosTeste.get(i);

             buffer.append(useCase.getSetUp() + "\n");

             if (linguagem.equals("Selenium")) {

                 buffer.append(testCase.toStringSelenium(useCase.getName()

                         + "-CT", i));

             } else {

                 buffer.append(testCase.toString());

             }

             buffer.append(useCase.getTearDown() + "\n");

         }

         return buffer.toString();

     }

     public String mostraTestManager(Projeto projeto, CasoUso useCase) {

         StringBuffer buffer = new StringBuffer();

         buffer

                 .append("<?xml version=\"1.0\"?>\n<TestAssetParcel>\n<TestPlan>\n<Name><![CDATA[Test Plan 1]]></Name>");

         buffer

                 .append("\n <Description/>\n  <CreationDate><![CDATA[2008:02:26:13:44:02]]></CreationDate>");

         buffer

                 .append("\n<ModificationDate><![CDATA[2008:02:26:13:44:02]]></ModificationDate>");

         buffer

                 .append("\n<LastModifiedBy><![CDATA[TestManagementSystem]]></LastModifiedBy>");

         buffer

                 .append("\n<CreatedBy><![CDATA[TestManagementSystem]]></CreatedBy>");

         buffer.append("\n<Owner><![CDATA[TestManagementSystem]]></Owner>");

         buffer.append("\n<Custom1/>");

         buffer.append("\n<Custom2/><Custom3/>");

         buffer.append("\n<ExternalDocument-List/>");

         buffer

                 .append("\n<Iteration-List/>\n<Configuration-List/>\n<TestCaseFolder>");

         buffer.append("\n<Name><![CDATA["

                 + this.tiraCaracteres(useCase.getName()) + "]]></Name>");

         buffer

                 .append("\n<Description/>\n<CreationDate><![CDATA[2008:02:26:13:44:02]]></CreationDate>");

         buffer

                 .append("\n<ModificationDate>\n<![CDATA[2008:02:26:13:44:02]]>\n</ModificationDate>");

         buffer

                 .append("\n<LastModifiedBy>\n<![CDATA[TestManagementSystem]]>\n</LastModifiedBy>");

         buffer

                 .append("\n<CreatedBy>\n<![CDATA[TestManagementSystem]]>\n</CreatedBy>");

         buffer.append("\n<Owner>\n<![CDATA[TestManagementSystem]]>\n</Owner>");

         buffer.append("\n<Iteration-List/>");

         buffer.append("\n<Configuration-List/>");

         for (int i = 0; i <= this.casosDeTesteData.size() - 1; i++) {

             buffer.append("\n<TestCase>");

             CasosTeste test = this.casosDeTesteData.get(i);

             String nomeCasoUso = useCase.getName();

             if (nomeCasoUso.length() >= 20) {

                 nomeCasoUso = nomeCasoUso.substring(0, 19);

             }

             String descricao = "Caso de teste que realiza os testes de sistema dos fluxos:\n";

             List<Fluxo> fluxos = test.getFlows();

             for (Object object : fluxos) {

                 Fluxo flow = (Fluxo) object;

                 String novoFluxo = this.tiraCaracteres(flow.getName());

                 if (!(descricao.contains(novoFluxo))) {

                     descricao += novoFluxo + "\n";

                 }

             }

             buffer.append("\n<Name><![CDATA["

                     + this.tiraCaracteres(nomeCasoUso + "-CT") + i

                     + "]]></Name>");

             buffer.append("\n<Description>");

             buffer.append("\n<![CDATA[");

             buffer.append(descricao);

             buffer.append("]]></Description>");

             buffer

                     .append("\n<CreationDate><![CDATA[2008:02:26:13:44:35]]></CreationDate>");

             buffer

                     .append("\n<ModificationDate>\n<![CDATA[2008:02:26:13:46:01]]>\n</ModificationDate>");

             buffer

                     .append("\n<LastModifiedBy>\n<![CDATA[admin]]>\n</LastModifiedBy>");

             buffer.append("\n<CreatedBy>\n<![CDATA[admin]]>\n</CreatedBy>");

             buffer.append("\n<Owner>\n<![CDATA[admin]]>\n</Owner>");

             buffer

                     .append("\n<Purpose/>\n<Custom1/>\n<Custom2/>\n<Custom3/>\n<Preconditions/>");

             buffer

                     .append("\n<PreconditionsInherited><![CDATA[0]]></PreconditionsInherited>");

             buffer

                     .append("\n<Postconditions/>"

                             + "\n<PostconditionsInherited><![CDATA[0]]></PostconditionsInherited>"

                             + "\n<Configured><![CDATA[0]]></Configured>"

                             + "\n<Suspect><![CDATA[0]]></Suspect>"

                             + "\n<ExternalDocument-List/>"

                             + "\n<TestInput-List/>"

                             + "\n<AcceptanceCriteria/>"

                             + "\n<AcceptanceCriteriaInherited><![CDATA[0]]></AcceptanceCriteriaInherited>"

                             + "\n<AutoImplementationInherited><![CDATA[0]]></AutoImplementationInherited>"

                             + "\n<ManualImplementation>"

                             + "<ScriptName><![CDATA["

                             + this.tiraCaracteres(nomeCasoUso)

                             + "-CT"

                             + i

                             + "]]></ScriptName>"

                             + "<ScriptSource><![CDATA[Manual - (Rational Test Datastore)]]></ScriptSource>"

                             + "</ManualImplementation>"

                             + "<ManualImplementationInherited><![CDATA[0]]></ManualImplementationInherited>"

                             + "\n<DesignStep-List>");

             List<CasoTesteStep> steps = test.getPassos();

             for (CasoTesteStep casoTesteStep : steps) {

                 Step element = casoTesteStep.getStep();

                 buffer.append("\n<DesignStep>\n<Type><![CDATA[Step]]></Type>");

                 buffer.append("\n<Description><![CDATA["

                         + this.tiraCaracteres(element.getDescricao())

                         + "]]></Description>");

                 buffer

                         .append("\n<Notes><![CDATA[@@none]]></Notes>\n</DesignStep>");

             }

             buffer.append("\n</DesignStep-List>"

                     + "\n<ExecutionOption-List/>\n<State><![CDATA[0]]></State>"

                     + "\n<StateComment/>" + "\n<Points><![CDATA[1]]></Points>"

                     + "\n<PointsInherited><![CDATA[0]]></PointsInherited>"

                     + "\n<PointsAttempted><![CDATA[0]]></PointsAttempted>"

                     + "\n<PointsPass><![CDATA[0]]></PointsPass>"

                     + "\n<PointsFail><![CDATA[0]]></PointsFail>"

                     + "\n<Iteration-List/>" + "\n<Configuration-List/>"

                     + "\n<Input-List/>" + "\n</TestCase>");

         }

         buffer.append("</TestCaseFolder> </TestPlan>");

         buffer

                 .append("\n<TestScriptSource>"

                         + " \n <Name><![CDATA[Manual - (Rational Test Datastore)]]></Name>"

                         + "\n<Description/>"

                         + "   \n <CreationDate><![CDATA[2008:02:26:13:44:01]]></CreationDate>"

                         + "\n<ModificationDate><![CDATA[2008:02:26:13:44:01]]></ModificationDate>"

                         + "  \n  <LastModifiedBy><![CDATA[TestManagementSystem]]></LastModifiedBy>"

                         + "\n<CreatedBy><![CDATA[TestManagementSystem]]></CreatedBy>"

                         + "   \n <Owner><![CDATA[TestManagementSystem]]></Owner>"

                         + "\n<DataPath><![CDATA[0]]></DataPath>"

                         + "  \n  <DataPathSpecificity><![CDATA[0]]></DataPathSpecificity>"

                         + "\n<ConfigurationData/>"

                         + "   \n <ConnectionOption-List>"

                         + "\n<ConnectionOption>"

                         + "\n<Name><![CDATA[Default Datastore]]></Name>"

                         + "      \n  <Op/>"

                         + "\n<Value><![CDATA[1]]></Value>"

                         + "\n</ConnectionOption>"

                         + "     \n <ConnectionOption>"

                         + "\n<Name><![CDATA[Type]]></Name>"

                         + "       \n <Op/>"

                         + "\n<Value><![CDATA[Manual]]></Value>"

                         + "\n</ConnectionOption>"

                         + "\n</ConnectionOption-List>"

                         + "   \n <Flags><![CDATA[0]]></Flags>"

                         + "\n<ExecutionOption-List/>"

                         + "   \n <DatapoolPath/>"

                         + "\n<DatapoolPathSpecificity><![CDATA[0]]></DatapoolPathSpecificity>"

                         + "   \n <EnableVersioning><![CDATA[0]]></EnableVersioning>"

                         + "\n<Associated-ScriptType><![CDATA[Manual Script]]></Associated-ScriptType>"

                         + "\n</TestScriptSource>"

                         + " \n <TestScriptType>"

                         + "\n<Name><![CDATA[Manual Script]]></Name>"

                         + "   \n <Description/>"

                         + "\n<CreationDate><![CDATA[2008:02:26:13:44:01]]></CreationDate>"

                         + "   \n <ModificationDate><![CDATA[2008:02:26:13:44:01]]></ModificationDate>"

                         + "\n<LastModifiedBy><![CDATA[TestManagementSystem]]></LastModifiedBy>"

                         + "   \n <CreatedBy><![CDATA[TestManagementSystem]]></CreatedBy>"

                         + "\n<Owner><![CDATA[TestManagementSystem]]></Owner>"

                         + "   \n <ConsoleAdapterName><![CDATA[rtconsoleadapter]]></ConsoleAdapterName>"

                         + "\n<ExecutionAdapterName><![CDATA[rttseacmd]]></ExecutionAdapterName>"

                         + "  \n  <ConsoleAdapterType><![CDATA[1]]></ConsoleAdapterType>"

                         + "\n<ExecutionAdapterType><![CDATA[2]]></ExecutionAdapterType>"

                         + "   \n <NewMethod/>"

                         + "\n<EditMethod/>"

                         + "   \n <SelectMethod/>"

                         + "\n<RecordMethod/>"

                         + "   \n <ExecutionMethod><![CDATA[RTManualTest -run {testscript} -project \"{project}\" -user \"{username}\" -password \"{password}\"]]></ExecutionMethod>"

                         + "\n<ExecutionOption-List/>"

                         + "   \n <SelectUseFileDlg><![CDATA[0]]></SelectUseFileDlg>"

                         + "\n<ConsoleAdapterPath/>"

                         + "   \n <ExecutionAdapterPath/>"

                         + "\n<Flags><![CDATA[0]]></Flags>"

                         + "   \n <Type><![CDATA[32]]></Type>"

                         + "\n<MaxTesters><![CDATA[1]]></MaxTesters>"

                         + "   \n <ScriptSource-List>"

                         + "\n<Associated-ScriptSource><![CDATA[Manual - (Rational Test Datastore)]]></Associated-ScriptSource>"

                         + "\n</ScriptSource-List>" + "\n</TestScriptType>");

         for (int i = 0; i <= this.casosDeTesteData.size() - 1; i++) {

             CasosTeste test = this.casosDeTesteData.get(i);

             String nomeCasoUso = useCase.getName();

             if (nomeCasoUso.length() >= 20) {

                 nomeCasoUso = nomeCasoUso.substring(0, 19);

             }

             buffer

                     .append("\n<Script>" + "\n<Name><![CDATA["

                             + this.tiraCaracteres(nomeCasoUso)

                             + "-CT"

                             + i

                             + "]]></Name>"

                             + "  \n  <Description/>"

                             + "\n<CreationDate><![CDATA[2008:02:26:18:06:19]]></CreationDate>"

                             + "  \n  <ModificationDate><![CDATA[2008:02:26:18:06:19]]></ModificationDate>"

                             + "\n<LastModifiedBy><![CDATA[admin]]></LastModifiedBy>"

                             + "  \n  <CreatedBy><![CDATA[admin]]></CreatedBy>"

                             + "\n<Owner><![CDATA[admin]]></Owner>"

                             + "   \n <Purpose/>" + "\n<Environment/>"

                             + "  \n  <Type><![CDATA[32]]></Type>"

                             + "\n<TypeName><![CDATA[Manual]]></TypeName>"

                             + "   \n <Custom1/>" + "\n<Custom2/>"

                             + "   \n <Custom3/>"

                             + "\n<Developed><![CDATA[0]]></Developed>"

                             + "   \n <SpecFilePath/>" + "\n<SpecNotes/>"

                             + "    \n<Define-List/>" + "\n<Library-List/>"

                             + "    \n<ClassPath/>" + "\n<DesignStep-List>");

             List<CasoTesteStep> steps = test.getPassos();

             for (CasoTesteStep casoTesteStep : steps) {

                 Step element = casoTesteStep.getStep();

                 if (!(this.pontoVerificacao(element.getDescricao()))) {

                     buffer

                             .append("\n<DesignStep>\n<Type><![CDATA[Step]]></Type>");

                 } else {

                     buffer.append("\n<DesignStep><Type><![CDATA[VP]]></Type>");

                 }

                 buffer.append("\n<Description><![CDATA["

                         + this.tiraCaracteres(element.getDescricao())

                         + "]]></Description>");

                 buffer

                         .append("\n<Notes><![CDATA[@@none]]></Notes>\n"

                                 + "\n<ExpectedResult><![CDATA[@@none]]></ExpectedResult>"

                                 + "\n<ExpectedResultFile><![CDATA[@@none]]></ExpectedResultFile>"

                                 + "\n</DesignStep>");

             }

             buffer.append("\n</DesignStep-List>");

             buffer.append("\n<FilePath><![CDATA[TMS_Scripts\\"

                     + this.tiraCaracteres(nomeCasoUso) + "-CT" + i

                     + ".]]></FilePath>");

             buffer.append("\n</Script>");

         }

         buffer.append("\n<ScriptFiles>");

         buffer.append("\n<ScriptFile-List/>");

         buffer.append("\n</ScriptFiles>");

         buffer.append("\n</TestAssetParcel>");

         return buffer.toString();

     }

     /***

      * Retorna caso de uso em um xml no formato do TestLink

      *

      * @param projeto Projeto do TestKase

      * @param useCase Caso de Uso

      * @return

      * @throws IOException

      */

     public String mostraTestLink(Projeto projeto, CasoUso useCase)

             throws IOException {

         StringBuffer buffer = new StringBuffer();

         buffer.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?><testcases>");

         String regra = Util.getPropriedade("testcasename");

         for (int i = 0; i <= this.casosDeTesteData.size() - 1; i++) {

             CasosTeste test = this.casosDeTesteData.get(i);

             String nome;

             if (regra != null) {

                 if (regra.contains("FN")) {

                     StringBuffer nomeFluxo = new StringBuffer();

                     for (Fluxo flow : test.getFlows()) {

                         String nomeReduzido = flow.getName().substring(0, 2);

                         if (!(nomeFluxo.toString().contains(nomeReduzido))) {

                             nomeFluxo.append(nomeReduzido);

                         }

                     }

                     nome = useCase.getName() + nomeFluxo.toString() + "-CT" + i;

                 } else {

                     nome = useCase.getName() + "-CT" + i;

                 }

                 if (regra.contains("DT")) {

                     nome += (new java.util.Date()).toString();

                 }

             } else {

                 nome = useCase.getName() + "-CT" + i;

             }

             buffer.append("<testcase name=\"" + nome + "\">");

             String descricao = "Caso de teste que realiza os testes de sistema dos fluxos:";

             List<Fluxo> fluxos = test.getFlows();

             for (Object object : fluxos) {

                 Fluxo flow = (Fluxo) object;

                 String novoFluxo = this.tiraCaracteres(flow.getName());

                 if (!(descricao.contains(novoFluxo))) {

                     descricao += novoFluxo + "<br>";

                 }

             }

             buffer.append("<summary><![CDATA[" + descricao + "]]></summary>");

             buffer.append("<steps><![CDATA[");

             List<CasoTesteStep> steps = test.getPassos();

             for (CasoTesteStep casoTesteStep : steps) {

                 Step element = casoTesteStep.getStep();

                 String passo;

                 try {

                     passo = new String(

                             element.getDescricao().getBytes("UTF-8"), "UTF-8");

                     buffer.append(HtmlEncoder.encode(passo) + "<br>");

                 } catch (UnsupportedEncodingException erro) {

                     ControladorErro.trata(erro, this);

                 }

             }

             buffer

                     .append("]]></steps><expectedresults><![CDATA[]]></expectedresults>");

             buffer.append("</testcase>");

         }

         buffer.append("</testcases>");

         return buffer.toString();

     }

     public ArrayList<CasosTeste> getCasosDeTeste() {

         return casosDeTeste;

     }

     public void setCasosDeTeste(ArrayList<CasosTeste> casosDeTeste) {

         this.casosDeTeste = casosDeTeste;

     }

     public ArrayList<CasosTeste> getCasosDeTesteData() {

         return casosDeTesteData;

     }

     public void setCasosDeTesteData(ArrayList<CasosTeste> casosDeTesteData) {

         this.casosDeTesteData = casosDeTesteData;

     }

     public boolean pontoVerificacao(String s) {

         if (s.contains("Verificar")) {

             return true;

         }

         if (s.contains("Validar")) {

             return true;

         }

         return false;

     }

     public String tiraCaracteres(String s) {

         return s.replace("�", "c").replace("�", "e").replace("�", "a").replace(

                 "\"", "").replace("�", "o").replace("�", "o").replace("�", "u")

                 .replace("�", "i").replace("�", "a").replace("�", "a").replace(

                         "�", "U").replace("�", "").replace("�", "").replace(

                         "�", "").replace("�", "").replace("�", "a").replace(

                         "�", "o").replace("�", "e").replace("�", "o").replace(

                         "�", "A").replace("�", "A").replace("�", "C").replace(

                         "�", "O").replace("�", "I").replace("�", "o").replace(

                         "�", "O").replace("�", " ");

     }

     public void bestPathProbalilidadeRandom(Fluxo flow, int number,

             CasosTeste casoTeste, int points, CasoUso useCase) {

         try {

             if (!(Algoritmo.flows.containsKey(flow.getName()))) {

                 Algoritmo.flows.put(flow.getName(), flow);

             }

             casoTeste.getFlows().add(flow);

             while (number <= flow.getSteps().size() - 1) {

                 Step step = (Step) ((Fluxo) Algoritmo.flows.get(flow.getName()))

                         .getSteps().get(number);

                 CasoTesteStep casoStep = new CasoTesteStep();

                 casoStep.setStep(step);

                 casoTeste.getPassos().add(casoStep);

                 step.setCoberto(true);

                 int numeroExecucoes = step.getNumberOfExecution();

                 if (numeroExecucoes > (useCase.getFlows().size() * 2)) {

                     break;

                 }

                 step.setNumberOfExecution(numeroExecucoes + 1);

                 if (step.getRegras().size() > 0) {

                     for (int i = 0; i <= step.getRegras().size() - 1; i++) {

                         RegraNegocio regra = ((RegraNegocio) step.getRegras()

                                 .get(i));

                         if ((!(this.regrasCobertas.containsKey(regra.getName())))

                                 || (regra.isReuse())) {

                             for (Object elemento : regra.getSteps()) {

                                 Step stepRegra = (Step) elemento;