private static SemanticaList CriaListaDefault(GPSolutionDefinition sh)
        {
            string listName = "default";

            sh.CreateListByName(listName, config.minLevels, config.maxLevels);
            GPSemantica       semanticaF1 = new GPSemanticaFormula("f1", 2, 3);
            GPSemantica       semanticaF2 = new GPSemanticaFormula("f2", 2, 2);
            GPSemantica       semanticaF3 = new GPSemanticaFormula("f3", 2, 3);
            GPSemantica       semanticaF4 = new GPSemanticaFormula("f4", 1, 1);
            GPSemantica       semanticaF5 = new GPSemanticaFormula("f5", 0, 0);
            GPSemanticaNumber semanticaN1 = new GPSemanticaNumber("0 a 100", 0, 100);

            sh.AddSemanticaToList(listName, semanticaF1);
            sh.AddSemanticaToList(listName, semanticaF2);
            sh.AddSemanticaToList(listName, semanticaF3);
            sh.AddSemanticaToList(listName, semanticaF5);
            sh.AddSemanticaToList(listName, semanticaN1);


            SemanticaList lista = sh.GetListByName(listName);

            lista.minLevels = config.minLevels;
            lista.maxLevels = config.maxLevels;
            Assert.IsTrue(lista.Contains(semanticaF1));
            Assert.IsTrue(lista.Contains(semanticaF2));
            Assert.IsTrue(lista.Contains(semanticaF3));
            Assert.IsFalse(lista.Contains(semanticaF4));
            sh.AddSemanticaToList(listName, semanticaF4);
            Assert.IsTrue(lista.Contains(semanticaF4));
            return(lista);
        }
        private void AddSemanticaFormula(string name, int min, int max)
        {
            GPSemantica semantica = new GPSemanticaFormula(name, min, max);

            base.AddSemanticaFormula(name, semantica);
            AddSemanticaToList(GPConsts.LISTA_FORMULA, semantica);
        }
        public void TestGPNode()
        {
            //pai: PAI(FILHO,NUMBER)
            GPSemantica semanticaPai  = new GPSemanticaFormula("PAI", 2, 2);
            GPSemantica semanticaPai2 = new GPSemanticaFormula("PAI2", 2, 3);

            Assert.IsFalse(semanticaPai.IsTerminal);

            //filho: TERMINAL

            GPSemantica semanticaNumber = new GPSemanticaNumber("Numero de 0 a 10", 0, 10000);

            GPSemantica semanticaFilho = new GPSemanticaFormula("FILHO", 0, 0);
            //neto: NETO(NUMBER)
            GPSemantica semanticaNeto = new GPSemanticaFormula("NETO", 1, 2);

            // GPSemantica semanticaNumber2 = new GPSemantica("NETO");
            Assert.IsTrue(semanticaFilho.IsTerminal);

            GPAbstractNode nodePai     = new GPNode(semanticaPai);
            GPAbstractNode nodePai2    = new GPNode(semanticaPai2);
            GPAbstractNode nodeFilho   = new GPNode(semanticaFilho);
            GPAbstractNode nodeNeto    = new GPNode(semanticaNeto);
            GPAbstractNode nodeNumber  = new GPNodeNumber(semanticaNumber, 10);
            GPAbstractNode nodeNumber2 = new GPNodeNumber(semanticaNumber, 1050.123f);

            Assert.IsTrue(nodePai.CanAddNode(nodeFilho));
            Assert.IsTrue(nodePai.CanAddNode(nodeNumber));
            nodePai.AddNode(nodeFilho);
            Assert.IsFalse(nodePai.CanAddNode(nodeFilho));//já foi adicionado
            Assert.IsTrue(nodePai.CanAddNode(nodeNumber));
            nodePai.AddNode(nodeNumber);
            Assert.IsFalse(nodePai.CanAddNode(nodeFilho));
            Assert.IsFalse(nodePai.CanAddNode(nodeNumber));

            Assert.IsFalse(nodeNumber.CanAddNode(nodeFilho));
            Assert.IsFalse(nodeNumber.CanAddNode(nodeNumber));
            Assert.IsFalse(nodeFilho.CanAddNode(nodeNumber));
            Assert.IsFalse(nodeFilho.CanAddNode(nodeFilho));
            Assert.IsFalse(nodeFilho.CanAddNode(nodeNeto));

            Assert.IsTrue(nodePai.ToString() == "PAI(FILHO,10)", nodePai.ToString() + "<>" + "PAI(FILHO,10)");

            Assert.IsFalse(nodeNeto.CanAddNode(nodeFilho));

            Assert.IsTrue(nodePai.ContainsNode(nodeFilho));
            Assert.IsFalse(nodePai.ContainsNode(nodeNeto));

            nodePai2.AddNode(nodeNeto);
            Assert.IsTrue(nodePai2.ContainsNode(nodeNeto));
            Assert.IsTrue(nodeNeto.nodePai == nodePai2);

            Assert.IsTrue(nodePai.TransferNode(nodeFilho, nodeNeto));
            Assert.IsFalse(nodePai.ContainsNode(nodeFilho));
            Assert.IsTrue(nodePai.ContainsNode(nodeNeto));
            Assert.IsTrue(nodePai2.ContainsNode(nodeFilho));

            Assert.IsTrue(nodeNeto.nodePai == nodePai, nodeNeto.nodePai + "<>" + nodePai);
            Assert.IsTrue(nodeFilho.nodePai == nodePai2, nodeFilho.nodePai.ToString());
            nodeNeto.AddNode(nodeNumber2);

            Assert.IsTrue(nodePai.ToString() == "PAI(NETO(1050.123),10)", nodePai.ToString() + "<>" + "PAI(NETO(1050.123),10)");
            Assert.IsTrue(nodePai.Size() == 4, nodePai.Size() + "<>" + 4);
            Assert.IsTrue(nodeNumber.Size() == 1, nodeNumber.Size() + "<>" + 1);

            Assert.IsTrue(nodePai.SizeLevel() == 3, nodePai.SizeLevel() + "<>" + 3);
        }