Commits

Miguel Roman committed af6c596

Se renombro el namespace servicios a Parsers.

  • Participants
  • Parent commits 530a1ef

Comments (0)

Files changed (11)

File App/Program.cs

-using Core.Servicios;
+using Core.Parsers;
 using System;
 
 namespace App

File Core/Core.csproj

     <Compile Include="Entidades\Terminal.cs" />
     <Compile Include="Entidades\Variable.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Servicios\GramaticaParser.cs" />
-    <Compile Include="Servicios\ProduccionParser.cs" />
+    <Compile Include="Parsers\GramaticaParser.cs" />
+    <Compile Include="Parsers\ProduccionParser.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

File Core/Parsers/GramaticaParser.cs

+using Core.Entidades;
+using Seterlund.CodeGuard;
+using System;
+using System.IO;
+using System.IO.Abstractions;
+using System.Linq;
+
+namespace Core.Parsers
+{
+    /// <summary>
+    /// Clase que permite leer la especificación de una gramatica desde un archivo de texto plano.
+    /// </summary>
+    public class GramaticaParser
+    {
+        /// <summary>
+        /// Componente que permite acceder al sistema de archivos.
+        /// </summary>
+        private readonly IFileSystem fileSystem;
+
+        /// <summary>
+        /// Componente que permite interpretar producciones desde cadenas de texto.
+        /// </summary>
+        private readonly ProduccionParser produccionParser;
+
+        /// <summary>
+        /// Constructor por defecto de la clase.
+        /// </summary>
+        public GramaticaParser()
+        {
+            this.fileSystem = new FileSystem();
+            this.produccionParser = new ProduccionParser();
+        }
+
+        /// <summary>
+        /// Sobrecarga del constructor de la clase para sustituir las dependencias.
+        /// </summary>
+        /// <param name="fileSystem">Systema de archivos</param>
+        public GramaticaParser(IFileSystem fileSystem)
+        {
+            Guard.That(fileSystem, "fileSystem").IsNotNull();
+            this.fileSystem = fileSystem;
+            this.produccionParser = new ProduccionParser();
+        }
+
+        /// <summary>
+        /// Lee la especificación de una gramática desde el archivo ubicado en <paramref name="ruta"/>.
+        /// </summary>
+        /// <param name="ruta">Ruta en la que se encuentra ubicado el archivo.</param>
+        /// <returns>Retorna la gramatica construida según la especificación del archivo.</returns>
+        public Gramatica ObtenerDesdeArchivo(string ruta)
+        {
+            if (!fileSystem.File.Exists(ruta))
+            {
+                throw new FileNotFoundException("El archivo especificado no existe", fileSystem.Path.GetFileName(ruta));
+            }
+
+            var gramatica = new Gramatica();
+
+            using (var reader = new StreamReader(fileSystem.File.OpenRead(ruta)))
+            {
+                var indice = 0;
+
+                while (!reader.EndOfStream)
+                {
+                    indice++;
+                    var linea = reader.ReadLine();
+
+                    if (string.IsNullOrWhiteSpace(linea)) continue;
+
+                    var partes = linea.Split(':');
+
+                    if (partes.Length != 2)
+                    {
+                        throw new InvalidOperationException(string.Format("La línea {0} no es válida, se esperaban dos puntos (:).", indice));
+                    }
+                    else
+                    {
+                        var nombreVariable = partes[0].Trim();
+
+                        var variable = gramatica.AgregarVariable(nombreVariable);
+
+                        var textoProducciones = partes[1].Trim();
+
+                        foreach (var regla in textoProducciones.Split('|'))
+                        {
+                            var produccion = produccionParser.ObtenerProduccion(gramatica, regla);
+                            if (produccion.Count() > 0)
+                            {
+                                gramatica.AgregarRegla(variable, produccion);
+                            }
+                        }
+                    }
+                }
+            }
+
+            return gramatica;
+        }
+    }
+}

File Core/Parsers/ProduccionParser.cs

+using Core.Entidades;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace Core.Parsers
+{
+    /// <summary>
+    /// Clase que brinda la funcionalidad necesaria para formar las producciones de una regla gramatical con base en una cadena de texto.
+    /// </summary>
+    public class ProduccionParser
+    {
+
+        private readonly Regex expresionRegular = new Regex(@"'(?<terminales>.+?)'|(?<epsilon>e)|(?<variables>\w+)", RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled | RegexOptions.CultureInvariant);
+
+        public IEnumerable<object> ObtenerProduccion(Gramatica gramatica, string produccion)
+        {
+            var concatenacion = new List<object>();
+
+
+            var matches = expresionRegular.Matches(produccion);
+
+            foreach (Match match in matches)
+            {
+                if (match.Success)
+                {
+                    var grupoTerminales = match.Groups["terminales"];
+                    var grupoVariables = match.Groups["variables"];
+                    var grupoEpsilon = match.Groups["epsilon"];
+
+                    if (grupoTerminales.Success)
+                    {
+                        var terminal = gramatica.AgregarTerminal(grupoTerminales.Value);
+                        concatenacion.Add(new Terminal(grupoTerminales.Value));
+                    }
+
+                    if (grupoVariables.Success)
+                    {
+                        var variable = gramatica.AgregarVariable(grupoVariables.Value);
+                        concatenacion.Add(variable);
+                    }
+
+                    if (grupoEpsilon.Success)
+                    {
+                        concatenacion.Add(new Terminal(null));
+                    }
+                }
+            }
+
+            return concatenacion;
+        }
+    }
+}

File Core/Servicios/GramaticaParser.cs

-using Core.Entidades;
-using Seterlund.CodeGuard;
-using System;
-using System.IO;
-using System.IO.Abstractions;
-using System.Linq;
-
-namespace Core.Servicios
-{
-    /// <summary>
-    /// Clase que permite leer la especificación de una gramatica desde un archivo de texto plano.
-    /// </summary>
-    public class GramaticaParser
-    {
-        /// <summary>
-        /// Componente que permite acceder al sistema de archivos.
-        /// </summary>
-        private readonly IFileSystem fileSystem;
-
-        /// <summary>
-        /// Componente que permite interpretar producciones desde cadenas de texto.
-        /// </summary>
-        private readonly ProduccionParser produccionParser;
-
-        /// <summary>
-        /// Constructor por defecto de la clase.
-        /// </summary>
-        public GramaticaParser()
-        {
-            this.fileSystem = new FileSystem();
-            this.produccionParser = new ProduccionParser();
-        }
-
-        /// <summary>
-        /// Sobrecarga del constructor de la clase para sustituir las dependencias.
-        /// </summary>
-        /// <param name="fileSystem">Systema de archivos</param>
-        public GramaticaParser(IFileSystem fileSystem)
-        {
-            Guard.That(fileSystem, "fileSystem").IsNotNull();
-            this.fileSystem = fileSystem;
-            this.produccionParser = new ProduccionParser();
-        }
-
-        /// <summary>
-        /// Lee la especificación de una gramática desde el archivo ubicado en <paramref name="ruta"/>.
-        /// </summary>
-        /// <param name="ruta">Ruta en la que se encuentra ubicado el archivo.</param>
-        /// <returns>Retorna la gramatica construida según la especificación del archivo.</returns>
-        public Gramatica ObtenerDesdeArchivo(string ruta)
-        {
-            if (!fileSystem.File.Exists(ruta))
-            {
-                throw new FileNotFoundException("El archivo especificado no existe", fileSystem.Path.GetFileName(ruta));
-            }
-
-            var gramatica = new Gramatica();
-
-            using (var reader = new StreamReader(fileSystem.File.OpenRead(ruta)))
-            {
-                var indice = 0;
-
-                while (!reader.EndOfStream)
-                {
-                    indice++;
-                    var linea = reader.ReadLine();
-
-                    if (string.IsNullOrWhiteSpace(linea)) continue;
-
-                    var partes = linea.Split(':');
-
-                    if (partes.Length != 2)
-                    {
-                        throw new InvalidOperationException(string.Format("La línea {0} no es válida, se esperaban dos puntos (:).", indice));
-                    }
-                    else
-                    {
-                        var nombreVariable = partes[0].Trim();
-
-                        var variable = gramatica.AgregarVariable(nombreVariable);
-
-                        var textoProducciones = partes[1].Trim();
-
-                        foreach (var regla in textoProducciones.Split('|'))
-                        {
-                            var produccion = produccionParser.ObtenerProduccion(gramatica, regla);
-                            if (produccion.Count() > 0)
-                            {
-                                gramatica.AgregarRegla(variable, produccion);
-                            }
-                        }
-                    }
-                }
-            }
-
-            return gramatica;
-        }
-    }
-}

File Core/Servicios/ProduccionParser.cs

-using Core.Entidades;
-using System.Collections.Generic;
-using System.Text.RegularExpressions;
-
-namespace Core.Servicios
-{
-    /// <summary>
-    /// Clase que brinda la funcionalidad necesaria para formar las producciones de una regla gramatical con base en una cadena de texto.
-    /// </summary>
-    public class ProduccionParser
-    {
-
-        private readonly Regex expresionRegular = new Regex(@"'(?<terminales>.+?)'|(?<epsilon>e)|(?<variables>\w+)", RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled | RegexOptions.CultureInvariant);
-
-        public IEnumerable<object> ObtenerProduccion(Gramatica gramatica, string produccion)
-        {
-            var concatenacion = new List<object>();
-
-
-            var matches = expresionRegular.Matches(produccion);
-
-            foreach (Match match in matches)
-            {
-                if (match.Success)
-                {
-                    var grupoTerminales = match.Groups["terminales"];
-                    var grupoVariables = match.Groups["variables"];
-                    var grupoEpsilon = match.Groups["epsilon"];
-
-                    if (grupoTerminales.Success)
-                    {
-                        var terminal = gramatica.AgregarTerminal(grupoTerminales.Value);
-                        concatenacion.Add(new Terminal(grupoTerminales.Value));
-                    }
-
-                    if (grupoVariables.Success)
-                    {
-                        var variable = gramatica.AgregarVariable(grupoVariables.Value);
-                        concatenacion.Add(variable);
-                    }
-
-                    if (grupoEpsilon.Success)
-                    {
-                        concatenacion.Add(new Terminal(null));
-                    }
-                }
-            }
-
-            return concatenacion;
-        }
-    }
-}

File Tests/Parsers/GramaticaParserTests.cs

+
+using Core.Entidades;
+using Core.Parsers;
+using NUnit.Framework;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions.TestingHelpers;
+using System.Linq;
+
+namespace Tests.Parsers
+{
+    [TestFixture]
+    public class GramaticaParserTests
+    {
+
+        const string gramatica_001 = @"A:'a'B
+A:'b'A
+B:'a'B
+B:'b'C
+B:'b'
+C:'a'B
+C:'b'B";
+
+        const string gramatica_002 = @"A:'a'B|'b'A
+B:'a'B|'b'C|'b'
+C:'a'B|'b'B";
+
+        private static string ObtenerRuta(string archivo)
+        {
+            var assemblyLocation = typeof(GramaticaParser).Assembly.Location;
+            var assemblyPath = Path.GetDirectoryName(assemblyLocation);
+
+            return Path.Combine(assemblyPath, archivo);
+        }
+
+        [Test]
+        public void ObtenerDesdeArchivo_ConReglasVerticales_RetornaUnaGramaticaValida()
+        {
+
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"C:\gramatica-001.txt", new MockFileData(gramatica_001) }
+            });
+
+            var servicio = new GramaticaParser(fileSystem);
+            var A = new Variable("A");
+            var B = new Variable("B");
+            var C = new Variable("C");
+            var a = new Terminal("a");
+            var b = new Terminal("b");
+            
+            var gramatica = servicio.ObtenerDesdeArchivo(@"C:\gramatica-001.txt");
+
+            Assert.IsNotNull(gramatica);
+            Assert.AreEqual(3, gramatica.Variables.Count);
+            Assert.AreEqual(2, gramatica.Terminales.Count);
+
+            Assert.AreEqual(new Variable("A"), gramatica.Variables.ElementAt(0));
+            Assert.AreEqual(new Variable("B"), gramatica.Variables.ElementAt(1));
+            Assert.AreEqual(new Variable("C"), gramatica.Variables.ElementAt(2));
+
+            Assert.AreEqual(new Terminal("a"), gramatica.Terminales.ElementAt(0));
+            Assert.AreEqual(new Terminal("b"), gramatica.Terminales.ElementAt(1));
+        }
+
+        [Test]
+        public void ObtenerDesdeArchivo_ConReglasVerticales_RetornaLasProduccionesEsperadas()
+        {
+
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"C:\gramatica-001.txt", new MockFileData(gramatica_001) }
+            });
+
+            var servicio = new GramaticaParser(fileSystem);
+            var gramatica = servicio.ObtenerDesdeArchivo(@"C:\gramatica-001.txt");
+
+            Assert.AreEqual(7, gramatica.Reglas.Count);
+
+            Assert.AreEqual(new Variable("A"), gramatica.Reglas.ElementAt(0).Variable);
+            Assert.AreEqual(new Variable("A"), gramatica.Reglas.ElementAt(1).Variable);
+            Assert.AreEqual(new Variable("B"), gramatica.Reglas.ElementAt(2).Variable);
+            Assert.AreEqual(new Variable("B"), gramatica.Reglas.ElementAt(3).Variable);
+            Assert.AreEqual(new Variable("B"), gramatica.Reglas.ElementAt(4).Variable);
+            Assert.AreEqual(new Variable("C"), gramatica.Reglas.ElementAt(5).Variable);
+            Assert.AreEqual(new Variable("C"), gramatica.Reglas.ElementAt(6).Variable);
+
+            Assert.That(gramatica.Reglas.ElementAt(0).Produccion, Is.EquivalentTo(new object[] { new Terminal("a"), new Variable("B") }));
+            Assert.That(gramatica.Reglas.ElementAt(1).Produccion, Is.EquivalentTo(new object[] { new Terminal("b"), new Variable("A") }));
+            Assert.That(gramatica.Reglas.ElementAt(2).Produccion, Is.EquivalentTo(new object[] { new Terminal("a"), new Variable("B") }));
+            Assert.That(gramatica.Reglas.ElementAt(3).Produccion, Is.EquivalentTo(new object[] { new Terminal("b"), new Variable("C") }));
+            Assert.That(gramatica.Reglas.ElementAt(4).Produccion, Is.EquivalentTo(new object[] { new Terminal("b") }));
+            Assert.That(gramatica.Reglas.ElementAt(5).Produccion, Is.EquivalentTo(new object[] { new Terminal("a"), new Variable("B") }));
+            Assert.That(gramatica.Reglas.ElementAt(6).Produccion, Is.EquivalentTo(new object[] { new Terminal("b"), new Variable("B") }));
+        }
+
+        [Test]
+        public void ObtenerDesdeArchivo_ConReglasHorizontales_RetornaUnaGramaticaValida()
+        {
+            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
+            {
+                { @"C:\gramatica-002.txt", new MockFileData(gramatica_002) }
+            });
+
+            var servicio = new GramaticaParser(fileSystem);
+            var A = new Variable("A");
+            var B = new Variable("B");
+            var C = new Variable("C");
+            var a = new Terminal("a");
+            var b = new Terminal("b");
+
+            var gramatica = servicio.ObtenerDesdeArchivo(@"C:\gramatica-002.txt");
+
+            Assert.IsNotNull(gramatica);
+            Assert.AreEqual(3, gramatica.Variables.Count);
+            Assert.AreEqual(2, gramatica.Terminales.Count);
+
+            Assert.AreEqual(new Variable("A"), gramatica.Variables.ElementAt(0));
+            Assert.AreEqual(new Variable("B"), gramatica.Variables.ElementAt(1));
+            Assert.AreEqual(new Variable("C"), gramatica.Variables.ElementAt(2));
+
+            Assert.AreEqual(new Terminal("a"), gramatica.Terminales.ElementAt(0));
+            Assert.AreEqual(new Terminal("b"), gramatica.Terminales.ElementAt(1));
+        }
+
+    }
+}

File Tests/Parsers/ProduccionParserTests.cs

+using Core.Entidades;
+using Core.Parsers;
+using NUnit.Framework;
+
+namespace Tests.Parsers
+{
+    [TestFixture]
+    public class ProduccionParserTests
+    {
+        [Test]
+        public void ObtenerProduccion_ConUnaTerminal_RetornaUnaTerminal()
+        {
+            var esperado = new object[] { new Terminal("b") };
+            var parser = new ProduccionParser();
+            var gramatica = new Gramatica();
+
+            var resultado = parser.ObtenerProduccion(gramatica, "'b'");
+
+            Assert.That(resultado, Is.EquivalentTo(esperado));
+        }
+
+        [Test]
+        public void ObtenerProduccion_ConUnaTerminalYUnaVariable_RetornaUnaConcatenacion()
+        {
+            var esperado = new object[] { new Terminal("b"), new Variable("A") };
+            var parser = new ProduccionParser();
+            var gramatica = new Gramatica();
+
+            var resultado = parser.ObtenerProduccion(gramatica, "'b'A");
+
+            Assert.That(resultado, Is.EquivalentTo(esperado));
+        }
+
+        [Test]
+        public void ObtenerProduccion_ConVariableDeNombreLargo_InterpretaCorrectamenteElNombreLargo()
+        {
+            var esperado = new object[] { new Terminal("b"), new Variable("ABC"), new Terminal("c") };
+            var parser = new ProduccionParser();
+            var gramatica = new Gramatica();
+
+            var resultado = parser.ObtenerProduccion(gramatica, "'b'ABC'c'");
+
+            Assert.That(resultado, Is.EquivalentTo(esperado));
+        }
+
+        [Test]
+        public void ObtenerProduccion_ConReglasComplejas_RetornaUnaConcatenacionConVariosElementos()
+        {
+            var esperado = new object[] { new Terminal("if"), new Variable("CONDICION"), new Terminal("then") };
+            var parser = new ProduccionParser();
+            var gramatica = new Gramatica();
+
+            var resultado = parser.ObtenerProduccion(gramatica, "'if' CONDICION 'then'");
+
+            Assert.That(resultado, Is.EquivalentTo(esperado));
+        }
+    }
+}

File Tests/Servicios/GramaticaParserTests.cs

-
-using Core.Entidades;
-using Core.Servicios;
-using NUnit.Framework;
-using System.Collections.Generic;
-using System.IO;
-using System.IO.Abstractions.TestingHelpers;
-using System.Linq;
-
-namespace Tests.Servicios
-{
-    [TestFixture]
-    public class GramaticaParserTests
-    {
-
-        const string gramatica_001 = @"A:'a'B
-A:'b'A
-B:'a'B
-B:'b'C
-B:'b'
-C:'a'B
-C:'b'B";
-
-        const string gramatica_002 = @"A:'a'B|'b'A
-B:'a'B|'b'C|'b'
-C:'a'B|'b'B";
-
-        private static string ObtenerRuta(string archivo)
-        {
-            var assemblyLocation = typeof(GramaticaParser).Assembly.Location;
-            var assemblyPath = Path.GetDirectoryName(assemblyLocation);
-
-            return Path.Combine(assemblyPath, archivo);
-        }
-
-        [Test]
-        public void ObtenerDesdeArchivo_ConReglasVerticales_RetornaUnaGramaticaValida()
-        {
-
-            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
-            {
-                { @"C:\gramatica-001.txt", new MockFileData(gramatica_001) }
-            });
-
-            var servicio = new GramaticaParser(fileSystem);
-            var A = new Variable("A");
-            var B = new Variable("B");
-            var C = new Variable("C");
-            var a = new Terminal("a");
-            var b = new Terminal("b");
-            
-            var gramatica = servicio.ObtenerDesdeArchivo(@"C:\gramatica-001.txt");
-
-            Assert.IsNotNull(gramatica);
-            Assert.AreEqual(3, gramatica.Variables.Count);
-            Assert.AreEqual(2, gramatica.Terminales.Count);
-
-            Assert.AreEqual(new Variable("A"), gramatica.Variables.ElementAt(0));
-            Assert.AreEqual(new Variable("B"), gramatica.Variables.ElementAt(1));
-            Assert.AreEqual(new Variable("C"), gramatica.Variables.ElementAt(2));
-
-            Assert.AreEqual(new Terminal("a"), gramatica.Terminales.ElementAt(0));
-            Assert.AreEqual(new Terminal("b"), gramatica.Terminales.ElementAt(1));
-        }
-
-        [Test]
-        public void ObtenerDesdeArchivo_ConReglasVerticales_RetornaLasProduccionesEsperadas()
-        {
-
-            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
-            {
-                { @"C:\gramatica-001.txt", new MockFileData(gramatica_001) }
-            });
-
-            var servicio = new GramaticaParser(fileSystem);
-            var gramatica = servicio.ObtenerDesdeArchivo(@"C:\gramatica-001.txt");
-
-            Assert.AreEqual(7, gramatica.Reglas.Count);
-
-            Assert.AreEqual(new Variable("A"), gramatica.Reglas.ElementAt(0).Variable);
-            Assert.AreEqual(new Variable("A"), gramatica.Reglas.ElementAt(1).Variable);
-            Assert.AreEqual(new Variable("B"), gramatica.Reglas.ElementAt(2).Variable);
-            Assert.AreEqual(new Variable("B"), gramatica.Reglas.ElementAt(3).Variable);
-            Assert.AreEqual(new Variable("B"), gramatica.Reglas.ElementAt(4).Variable);
-            Assert.AreEqual(new Variable("C"), gramatica.Reglas.ElementAt(5).Variable);
-            Assert.AreEqual(new Variable("C"), gramatica.Reglas.ElementAt(6).Variable);
-
-            Assert.That(gramatica.Reglas.ElementAt(0).Produccion, Is.EquivalentTo(new object[] { new Terminal("a"), new Variable("B") }));
-            Assert.That(gramatica.Reglas.ElementAt(1).Produccion, Is.EquivalentTo(new object[] { new Terminal("b"), new Variable("A") }));
-            Assert.That(gramatica.Reglas.ElementAt(2).Produccion, Is.EquivalentTo(new object[] { new Terminal("a"), new Variable("B") }));
-            Assert.That(gramatica.Reglas.ElementAt(3).Produccion, Is.EquivalentTo(new object[] { new Terminal("b"), new Variable("C") }));
-            Assert.That(gramatica.Reglas.ElementAt(4).Produccion, Is.EquivalentTo(new object[] { new Terminal("b") }));
-            Assert.That(gramatica.Reglas.ElementAt(5).Produccion, Is.EquivalentTo(new object[] { new Terminal("a"), new Variable("B") }));
-            Assert.That(gramatica.Reglas.ElementAt(6).Produccion, Is.EquivalentTo(new object[] { new Terminal("b"), new Variable("B") }));
-        }
-
-        [Test]
-        public void ObtenerDesdeArchivo_ConReglasHorizontales_RetornaUnaGramaticaValida()
-        {
-            var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
-            {
-                { @"C:\gramatica-002.txt", new MockFileData(gramatica_002) }
-            });
-
-            var servicio = new GramaticaParser(fileSystem);
-            var A = new Variable("A");
-            var B = new Variable("B");
-            var C = new Variable("C");
-            var a = new Terminal("a");
-            var b = new Terminal("b");
-
-            var gramatica = servicio.ObtenerDesdeArchivo(@"C:\gramatica-002.txt");
-
-            Assert.IsNotNull(gramatica);
-            Assert.AreEqual(3, gramatica.Variables.Count);
-            Assert.AreEqual(2, gramatica.Terminales.Count);
-
-            Assert.AreEqual(new Variable("A"), gramatica.Variables.ElementAt(0));
-            Assert.AreEqual(new Variable("B"), gramatica.Variables.ElementAt(1));
-            Assert.AreEqual(new Variable("C"), gramatica.Variables.ElementAt(2));
-
-            Assert.AreEqual(new Terminal("a"), gramatica.Terminales.ElementAt(0));
-            Assert.AreEqual(new Terminal("b"), gramatica.Terminales.ElementAt(1));
-        }
-
-    }
-}

File Tests/Servicios/ProduccionParserTests.cs

-using Core.Entidades;
-using Core.Servicios;
-using NUnit.Framework;
-
-namespace Tests.Servicios
-{
-    [TestFixture]
-    public class ProduccionParserTests
-    {
-        [Test]
-        public void ObtenerProduccion_ConUnaTerminal_RetornaUnaTerminal()
-        {
-            var esperado = new object[] { new Terminal("b") };
-            var parser = new ProduccionParser();
-            var gramatica = new Gramatica();
-
-            var resultado = parser.ObtenerProduccion(gramatica, "'b'");
-
-            Assert.That(resultado, Is.EquivalentTo(esperado));
-        }
-
-        [Test]
-        public void ObtenerProduccion_ConUnaTerminalYUnaVariable_RetornaUnaConcatenacion()
-        {
-            var esperado = new object[] { new Terminal("b"), new Variable("A") };
-            var parser = new ProduccionParser();
-            var gramatica = new Gramatica();
-
-            var resultado = parser.ObtenerProduccion(gramatica, "'b'A");
-
-            Assert.That(resultado, Is.EquivalentTo(esperado));
-        }
-
-        [Test]
-        public void ObtenerProduccion_ConVariableDeNombreLargo_InterpretaCorrectamenteElNombreLargo()
-        {
-            var esperado = new object[] { new Terminal("b"), new Variable("ABC"), new Terminal("c") };
-            var parser = new ProduccionParser();
-            var gramatica = new Gramatica();
-
-            var resultado = parser.ObtenerProduccion(gramatica, "'b'ABC'c'");
-
-            Assert.That(resultado, Is.EquivalentTo(esperado));
-        }
-
-        [Test]
-        public void ObtenerProduccion_ConReglasComplejas_RetornaUnaConcatenacionConVariosElementos()
-        {
-            var esperado = new object[] { new Terminal("if"), new Variable("CONDICION"), new Terminal("then") };
-            var parser = new ProduccionParser();
-            var gramatica = new Gramatica();
-
-            var resultado = parser.ObtenerProduccion(gramatica, "'if' CONDICION 'then'");
-
-            Assert.That(resultado, Is.EquivalentTo(esperado));
-        }
-    }
-}

File Tests/Tests.csproj

   </ItemGroup>
   <ItemGroup>
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Servicios\GramaticaParserTests.cs" />
-    <Compile Include="Servicios\ProduccionParserTests.cs" />
+    <Compile Include="Parsers\GramaticaParserTests.cs" />
+    <Compile Include="Parsers\ProduccionParserTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />