public void PruebaConstructor()
        {
            // Preparación.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              ManejadorDeVías manejadorDePdis = new ManejadorDeVías(manejadorDeMapa, new List<Vía>(), escuchadorDeEstatus, null);

              // Llama al contructor bajo prueba.
              ArregladorGeneral objectoDePrueba = new ArregladorGeneral(manejadorDePdis, escuchadorDeEstatus);

              // Prueba propiedades.
              Assert.That(objectoDePrueba.NúmeroDeElementos, Is.EqualTo(0), "NúmeroDeElementos");
              Assert.That(objectoDePrueba.NúmeroDeProblemasDetectados, Is.EqualTo(0), "NúmeroDeElementosModificados");
        }
        public void PruebaConstructor()
        {
            // Preparación.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              ManejadorDePDIs manejadorDePDIs = new ManejadorDePDIs(manejadorDeMapa, new List<PDI>(), escuchadorDeEstatus);

              // Llama al contructor bajo prueba.
              BuscadorDeDuplicados objectoDePrueba = new BuscadorDeDuplicados(manejadorDePDIs, escuchadorDeEstatus);

              // Prueba propiedades.
              Assert.That(objectoDePrueba.NúmeroDeElementoProcesándose, Is.EqualTo(0), "NúmeroDeElementoProcesándose");
              Assert.That(objectoDePrueba.NúmeroDeElementos, Is.EqualTo(0), "NúmeroDeElementos");
              Assert.That(objectoDePrueba.NúmeroDeProblemasDetectados, Is.EqualTo(0), "NúmeroDeElementosModificados");
        }
        public void PruebaProcesaCaso1()
        {
            #region Preparación.
              // Crea el objeto a probar.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              ManejadorDeVías manejadorDeVías = new ManejadorDeVías(manejadorDeMapa, new List<Vía>(), escuchadorDeEstatus, null);
              ArregladorGeneral objectoDePrueba = new ArregladorGeneral(manejadorDeVías, escuchadorDeEstatus);

              // Caso de prueba.
              Caso[] casos = new[] {
            //         Nombre, IndicadorDeDirección, UnSoloSentido, IndicadorDeDirecciónEsperado, UnSoloSentidoEsperado
            new Caso (    "A",                  "0",         false,                          "0",                 false), // Calle doble sentido.
            new Caso (    "B",                  "0",          true,                          "1",                  true), // Indicador de dirección = 0.
            new Caso (    "C",                  "1",         false,                          "1",                  true), // Falta UnSoloSentido.
            new Caso (    "D",                  "1",          true,                          "1",                  true), // Calle un sentido.
            new Caso (    "E",                 null,          true,                          "1",                  true), // Falta indicador de dirección.
              };
              const int númeroDeProblemasDetectados = 3;

              // Crea los elementos.
              // Vía típica:
              //   [POLYLINE]
              //   Type=0x2
              //   Label=TRONCAL 9
              //   EndLevel=3
              //   DirIndicator=1
              //   CityIdx=1
              //   RoadID=47
              //   RouteParam=5,3,1,0,0,0,0,0,0,0,0,0
              //   Data0=(10.16300,-66.00000),(10.16199,-65.99850),(10.16010,-65.99591)
              IList<Vía> vías = manejadorDeVías.Elementos;
              const string clase = "POI";
              for (int i = 0; i < casos.Length; ++i)
              {
            Caso caso = casos[i];
            List<Campo> campos = new List<Campo> {
              new CampoTipo("0x2"),
              new CampoNombre (caso.Nombre),
              new CampoGenérico("EndLevel", "3"),
              new CampoParámetrosDeRuta(
            new LímiteDeVelocidad(5),
            new ClaseDeRuta(3),
            new[] {caso.UnSoloSentido, false, false, false, false, false, false, false, false, false} ),
              new CampoCoordenadas("Data", 0, new[]
                                            {
                                              new Coordenadas(10.16300,-66.00000),
                                              new Coordenadas(10.16199,-65.99850),
                                              new Coordenadas(10.16010,-65.99591),
                                            })
            };
            if ( caso.IndicadorDeDirección != null)
            {
              campos.Add(new CampoGenérico(Vía.IdentificadorIndicadorDeDirección, caso.IndicadorDeDirección));
            }

            Vía vía = new Vía(manejadorDeMapa, i, clase, campos);
            vías.Add(vía);
              }
              #endregion

              // Llama al método bajo prueba.
              objectoDePrueba.Procesa();

              // Prueba propiedades.
              Assert.That(objectoDePrueba.NúmeroDeElementos, Is.EqualTo(vías.Count), "NúmeroDeElementos");
              Assert.That(objectoDePrueba.NúmeroDeProblemasDetectados, Is.EqualTo(númeroDeProblemasDetectados), "NúmeroDeProblemasDetectados");

              // Prueba los nobres de los PDIs.
              for (int i = 0; i < casos.Length; ++i)
              {
            Assert.That(vías[i].CampoParámetrosDeRuta.OtrosParámetros[0], Is.EqualTo(casos[i].UnSoloSentidoEsperado), "Vía[" + i + "].OtrosParámetros[0]");
            Assert.That(vías[i].CampoIndicadorDeDirección, Is.Not.Null, "Vía[" + i + "].CampoIndicadorDeDirección");
            Assert.That(vías[i].CampoIndicadorDeDirección.Texto, Is.EqualTo(casos[i].IndicadorDeDirecciónEsperado), "Vía[" + i + "].CampoIndicadorDeDirección.Texto");
              }
        }
        public void PruebaConstructor()
        {
            // Preparación.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              IList<Pdi> pdis = new List<Pdi>();

              // Llama al contructor bajo prueba.
              ManejadorDePdis objectoDePrueba = new ManejadorDePdis(manejadorDeMapa, pdis, escuchadorDeEstatus);

              // Prueba propiedades.
              Assert.That(objectoDePrueba.Elementos, Is.EqualTo(pdis), "Elementos");
              Assert.That(objectoDePrueba.EscuchadorDeEstatus, Is.EqualTo(escuchadorDeEstatus), "EscuchadorDeEstatus");
              Assert.That(objectoDePrueba.ManejadorDeMapa, Is.EqualTo(manejadorDeMapa), "ManejadorDeMapa");
        }
        public void PruebaProcesa()
        {
            #region Preparación.
              // Crea el objeto a probar.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              ManejadorDePDIs manejadorDePDIs = new ManejadorDePDIs(manejadorDeMapa, new List<PDI>(), escuchadorDeEstatus);
              ArregladorDePalabrasPorTipo objectoDePrueba = new ArregladorDePalabrasPorTipo(manejadorDePDIs, escuchadorDeEstatus);

              // Caso de prueba.
              Caso[] casos = new Caso[] {
            //        Tipo,     Nombre Original, Nombre Corregido
            new Caso ("0x2a06", "RES LA COMIDA", "RESTAURANTE LA COMIDA"), // Cambia Nombre.
            new Caso ("0x2a07", "RES  LA  COMIDA", "RESTAURANTE LA COMIDA"), // Cambia nombre y elimina espacios.
            new Caso ("0x9999", "RES LA COMIDA", "RES LA COMIDA"),  // Este no debería cambiar porque el tipo no está en el rango.
            new Caso ("0x6402", "CONJ RES LAS TORRES", "CONJUNTO RESIDENCIAL LAS TORRES"), // Cambia Nombre.
              };
              int númeroDeProblemasDetectados = 6;

              // Crea los elementos.
              IList<PDI> pdis = manejadorDePDIs.Elementos;
              string clase = "POI";
              for (int i = 0; i < casos.Length; ++i)
              {
            Caso caso = casos[i];
            List<Campo> campos = new List<Campo> {
              new CampoNombre (caso.NombreOriginal),
              new CampoTipo (caso.Tipo)
            };

            PDI pdi = new PDI(manejadorDeMapa, i, clase, campos);
            pdis.Add(pdi);
              }
              #endregion

              // Llama al método bajo prueba.
              objectoDePrueba.Procesa();

              // Prueba propiedades.
              Assert.That(objectoDePrueba.NúmeroDeElementoProcesándose, Is.EqualTo(pdis.Count), "NúmeroDeElementoProcesándose");
              Assert.That(objectoDePrueba.NúmeroDeElementos, Is.EqualTo(pdis.Count), "NúmeroDeElementos");
              Assert.That(objectoDePrueba.NúmeroDeProblemasDetectados, Is.EqualTo(númeroDeProblemasDetectados), "NúmeroDeProblemasDetectados");

              // Prueba los nobres de los PDIs.
              for (int i = 0; i < casos.Length; ++i)
              {
            Assert.That(casos[i].NombreCorregido, Is.EqualTo(pdis[i].Nombre), "PDI[" + i + "].Nombre");
              }
        }
        public void PruebaProcesarTodo()
        {
            #region Preparación.
              // Crea el objeto a probar.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              ManejadorDePdis objectoDePrueba = new ManejadorDePdis(manejadorDeMapa, new List<Pdi>(), escuchadorDeEstatus);

              // Caso de prueba.
              Caso[] casos = new[] {
            //        Tipo,     Nombre Original, Nombre Corregido
            new Caso ("0x2a06", "RES. LA COMIDA", "RESTAURANTE LA COMIDA"), // Cambia Nombre.
            new Caso ("0x2a07", "RES  LA  COMIDA", "RESTAURANTE LA COMIDA"), // Cambia nombre y elimina espacios.
            new Caso ("0x9999", "RES LA COMIDA", "RES LA COMIDA"),  // Este no debería cambiar porque el tipo no está en el rango.
            new Caso ("0x6402", "CONJ. RESD. LAS TORRES", "CONJUNTO RESIDENCIAL LAS TORRES"), // Cambia Nombre.
              };

              // Crea los PDIs originales.
              IList<Pdi> pdis = objectoDePrueba.Elementos;
              const string clase = "POI";
              for (int i = 0; i < casos.Length; ++i)
              {
            Caso caso = casos[i];
            List<Campo> campos = new List<Campo> {
              new CampoNombre (caso.NombreOriginal),
              new CampoTipo (caso.Tipo)
            };

            Pdi pdi = new Pdi(manejadorDeMapa, i, clase, campos);
            pdis.Add(pdi);
              }

              // Crea los PDIs finales.
              IList<Pdi> pdisEsperados = new List<Pdi>(pdis.Count);
              for (int i = 0; i < pdis.Count; ++i)
              {
            Pdi pdiEsperado = (Pdi)pdis[i].Clone();
            string nombreEsperado = casos[i].NombreCorregido;
            if (pdiEsperado.Nombre != nombreEsperado)
            {
              pdiEsperado.ActualizaNombre(nombreEsperado, "");
            }

            pdisEsperados.Add(pdiEsperado);
              }
              #endregion

              // Llama al método bajo prueba.
              objectoDePrueba.ProcesarTodo();

              #region Prueba propiedades.
              // Prueba propiedad Elementos.
              for (int i = 0; i < objectoDePrueba.Elementos.Count; ++i)
              {
            Assert.That(objectoDePrueba.Elementos[i].Nombre, Is.EqualTo(pdisEsperados[i].Nombre), "Elementos[" + i + "].Nombre");
              }
              #endregion
        }
Exemple #7
0
        public void PruebaConstructor()
        {
            // Preparación.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              ManejadorDePdis manejadorDePdis = new ManejadorDePdis(manejadorDeMapa, new List<Pdi>(), escuchadorDeEstatus);

              // Llama al contructor bajo prueba.
              var objectoDePrueba = new BuscadorDeErrores(manejadorDePdis, escuchadorDeEstatus);

              // Prueba propiedades.
              Assert.That(objectoDePrueba.NúmeroDeElementos, Is.EqualTo(0), "NúmeroDeElementos");
              Assert.That(objectoDePrueba.NúmeroDeProblemasDetectados, Is.EqualTo(0), "NúmeroDeProblemasDetectados");
        }
Exemple #8
0
        public void PruebaProcesaCaso1()
        {
            #region Preparación.
              // Crea el objeto a probar.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              ManejadorDePdis manejadorDePdis = new ManejadorDePdis(manejadorDeMapa, new List<Pdi>(), escuchadorDeEstatus);
              var objectoDePrueba = new BuscadorDeErrores(manejadorDePdis, escuchadorDeEstatus);

              // Crea los elementos.
              IList<Pdi> pdis = manejadorDePdis.Elementos;
              const string clase = "POI";
              var campoCoordenadas = new CampoCoordenadas("Data", 0, new[]
            {
              new Coordenadas(10.16300,-66.00000),
              new Coordenadas(10.16199,-65.99850),
              new Coordenadas(10.16010,-65.99591),
            });

              var pdiNoCiudad = new Pdi(manejadorDeMapa, 1, clase, new List<Campo> {
            new CampoTipo("0x001"),
            campoCoordenadas});
              pdis.Add(pdiNoCiudad);

              var pdiCiudadCorrecta = new Pdi(manejadorDeMapa, 1, clase, new List<Campo> {
            new CampoTipo("0xb00"),
            new CampoEsCiudad(true),
            new CampoIndiceDeCiudad(79),
            campoCoordenadas});
              pdis.Add(pdiCiudadCorrecta);

              var pdiSinCampoEsCiudad = new Pdi(manejadorDeMapa, 1, clase, new List<Campo> {
            new CampoTipo("0xc00"),
            new CampoIndiceDeCiudad(79),
            campoCoordenadas});
              pdis.Add(pdiSinCampoEsCiudad);

              var pdiSinIndiceDeCiudad = new Pdi(manejadorDeMapa, 1, clase, new List<Campo> {
            new CampoTipo("0xd00"),
            new CampoEsCiudad(true),
            campoCoordenadas});
              pdis.Add(pdiSinIndiceDeCiudad);

              var pdiSinIndiceDeCiudadYConAttributo = new Pdi(manejadorDeMapa, 1, clase, new List<Campo> {
            new CampoTipo("0xf00"),
            new CampoAtributo(BuscadorDeErrores.AtributoIgnorarCamposCityYCityIdx),
            campoCoordenadas});
              pdis.Add(pdiSinIndiceDeCiudadYConAttributo);

              var pdiSinIndiceDeCiudadYSinCampoEsCiudad = new Pdi(manejadorDeMapa, 1, clase, new List<Campo> {
            new CampoTipo("0xe00"),
            campoCoordenadas});
              pdis.Add(pdiSinIndiceDeCiudadYSinCampoEsCiudad);

              // Deberian haber 3 errores:
              //   - 1 por el PDI sin campo de Ciudad.
              //   - 1 por el PDI sin índice de Ciudad.
              //   - 2 por el PDI sin campo de Ciudad y sin índice de Ciudad.
              const int númeroDeProblemasDetectados = 4;
              #endregion

              // Llama al método bajo prueba.
              objectoDePrueba.Procesa();

              // Prueba propiedades.
              Assert.That(objectoDePrueba.NúmeroDeElementos, Is.EqualTo(pdis.Count), "NúmeroDeElementos");
              Assert.That(objectoDePrueba.NúmeroDeProblemasDetectados, Is.EqualTo(númeroDeProblemasDetectados), "NúmeroDeProblemasDetectados");
              Assert.That(objectoDePrueba.Errores.Count, Is.EqualTo(númeroDeProblemasDetectados), "Errores.Count");

              Assert.That(
            objectoDePrueba.Errores[pdiSinCampoEsCiudad],
            Text.StartsWith("E004"),
            "Errores[pdiSinCampoEsCiudad]");

              Assert.That(
            objectoDePrueba.Errores[pdiSinIndiceDeCiudad],
            Text.StartsWith("E005"),
            "Errores[pdiSinIndiceDeCiudad]");

              Assert.That(
               objectoDePrueba.Errores[pdiSinIndiceDeCiudadYSinCampoEsCiudad],
               Text.StartsWith("E004"),
               "Errores[pdiSinIndiceDeCiudadYSinCampoEsCiudad]");

              Assert.That(
               objectoDePrueba.Errores[pdiSinIndiceDeCiudadYSinCampoEsCiudad],
               Text.Contains("E005"),
               "Errores[pdiSinIndiceDeCiudadYSinCampoEsCiudad]");

              Assert.That(
               objectoDePrueba.Errores.ContainsKey(pdiSinIndiceDeCiudadYConAttributo),
               Is.False,
               "Errores.ContainsKey(pdiSinIndiceDeCiudadYConAttributo)");

              Assert.That(
               objectoDePrueba.Errores.ContainsKey(pdiCiudadCorrecta),
               Is.False,
               "Errores.ContainsKey(pdiCiudadCorrecta)");
        }
        public void PruebaProcesa()
        {
            #region Preparación.
              // Crea el objeto a probar.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              ManejadorDePdis manejadorDePdis = new ManejadorDePdis(manejadorDeMapa, new List<Pdi>(), escuchadorDeEstatus);
              BuscadorDeDuplicados objectoDePrueba = new BuscadorDeDuplicados(manejadorDePdis, escuchadorDeEstatus);

              // Caso de prueba.
              Caso[] casos = new[] {
            //        Tipo,     Nombre         ,  Latitud, Longitud, Indice de Duplicados   , Es Eliminado, Descripción.
            new Caso ("0x2a06", "El PUNTO"     , 10.00000, 20.00000, new[] {2,3,6,7,9}      , false       , "PDI#1"),
            new Caso ("0x2a06", "El PUNTO"     , 10.00000, 20.00000, null                   , true        , "Idéntico: Mismos nombre, tipo, y coordenada de PDI#1 : es eliminado."),
            new Caso ("0x2a05", "El PUNTO"     , 10.00000, 20.00000, null                   , false       , "Mismo tipo principal: Mismo nombre, tipo principal, y coordenada de PDI#1: es duplicado."),
            new Caso ("0x2a06", "El PUNTO"     , 10.00001, 20.00000, null                   , false       , "Cercano: Mismo nombre y tipo de PDI#1, coordenadas cercanas: es duplicado."),
            new Caso ("0x2a06", "El PUNTO"     , 10.00000, 20.02000, null                   , false       , "Lejano: Mismo nombre y tipo de PDI#1, coordenadas lejanas: no es duplicado."),
            new Caso ("0x2b06", "El PUNTO"     , 10.00000, 20.00000, null                   , false       , "Diferente tipo principal: Mismo nombre y coordenada de PDI#1, diferente tipo principal: no es duplicado."),
            new Caso ("0x2a06", "EP"           , 10.00000, 20.00000, null                   , false       , "Siglas de PDI#1, misma coordenada de PDI#1: es duplicado."),
            new Caso ("0x2a06", "EP"           , 10.00000, 20.00000, null                   , false       , "Siglas de PDI#1, coordenadas cercanas: es duplicado."),
            new Caso ("0x2a06", " EP "         , 10.00000, 20.00000, null                   , false       , "Siglas de PDI#1 con espacios en blanco, coordenadas cercanas: no es duplicado."),
            new Caso ("0x2a06", "El PUMTO"     , 10.00000, 20.00000, null                   , false       , "Nombre similar a PDI#1, coordenadas cercanas: es duplicado."),
            new Caso ("0x2a06", "EOP"          , 15.00000, 20.00000, new[] { 11 }           , false       , "PDI#2"),
            new Caso ("0x2a06", "EL OTRO PUNTO", 15.00000, 20.00000, null                   , false       , "PDI#2 es las siglas, misma coordenadas: es duplicado."),
              };
              const int númeroDeDuplicadosDetectados = 2;

              // Crea los elementos.
              IList<Pdi> elementos = manejadorDePdis.Elementos;
              const string clase = "POI";
              for (int i = 0; i < casos.Length; ++i)
              {
            Caso caso = casos[i];
            List<Campo> campos = new List<Campo> {
              new CampoNombre (caso.Nombre),
              new CampoTipo (caso.Tipo),
              new CampoCoordenadas (
            CampoCoordenadas.IdentificadorDeCoordenadas,
            0,
            new Coordenadas (caso.Latitud, caso.Longitud))
            };

            Pdi pdi = new Pdi(manejadorDeMapa, i, clase, campos);
            elementos.Add(pdi);
              }

              // Crea los duplicados.
              Dictionary<Pdi, IList<Pdi>> duplicados = new Dictionary<Pdi, IList<Pdi>>();
              for (int i = 0; i < casos.Length; ++i)
              {
            Caso caso = casos[i];
            if (caso.IndicesDeLosDuplicados != null)
            {
              List<Pdi> pdisDuplicados = new List<Pdi>();
              foreach (int j in caso.IndicesDeLosDuplicados)
              {
            pdisDuplicados.Add(elementos[j]);
              }

              Pdi pdi = elementos[i];
              duplicados.Add(pdi, pdisDuplicados);
            }
              }
              #endregion

              // Llama al método bajo prueba.
              objectoDePrueba.Procesa();

              // Prueba propiedades.
              AseguraDuplicadosSonIguales(duplicados, objectoDePrueba.GruposDeDuplicados, "GruposDeDuplicados");
              Assert.AreEqual(elementos.Count, objectoDePrueba.NúmeroDeElementos, "NúmeroDeElementos");
              Assert.AreEqual(númeroDeDuplicadosDetectados, objectoDePrueba.NúmeroDeProblemasDetectados, "NúmeroDeProblemasDetectados");

              // Prueba que se hayan eliminados los PDIs idénticos.
              for (int i = 0; i < casos.Length; ++i)
              {
            Assert.AreEqual(casos[i].EsEliminado, elementos[i].FuéEliminado, "Elemento[" + i + "].FuéEliminado");
              }
        }
        public void PruebaConstructor()
        {
            #region Caso 1: Operación Normal
              {
            #region Preparación.
            // Lee un mapa de prueba.
            const string archivoDeEntrada = @"..\..\Data\PruebaEscritorFormatoPolish.mp";
            IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
            ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
            LectorDeFormatoPolish lector = new LectorDeFormatoPolish(manejadorDeMapa, archivoDeEntrada);
            IList<ElementoDelMapa> elementos = lector.ElementosDelMapa;

            const string archivoDeSalida = @"PruebaEscritorFormatoPolish.Caso1.mp";
            #endregion

            // Llama al constructor.
            new EscritorDeFormatoPolish(archivoDeSalida, elementos, escuchadorDeEstatus);

            #region Prueba Archivo de Salida.
            string[] líneasDeEntrada = LéeArchivo(archivoDeEntrada);
            string[] líneasDeSalida = LéeArchivo(archivoDeSalida);
            Assert.That(líneasDeSalida, Is.EqualTo(líneasDeEntrada), "Líneas");
            #endregion
              }
              #endregion

              #region Caso 2: Archivo de Salida inválido.
              {
            #region Preparación.
            // Crea elementos.
            IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
            IList<ElementoDelMapa> elementos = new List<ElementoDelMapa>();

            // Archivo inválido.
            const string archivoDeSalidaInválido = @"ABC::\\&AAAA";

            // Excepción esperada.
            bool lanzóExcepción = false;
            ArgumentException excepciónEsperada = new ArgumentException(
              "The path is not of a legal form.");
            #endregion

            // Llama al constructor en prueba.
            try
            {
              new EscritorDeFormatoPolish(archivoDeSalidaInválido, elementos, escuchadorDeEstatus);
            }
            catch (Exception e)
            {
              // Prueba las propiedades de la excepción.
              Assert.That(e.GetType(), Is.EqualTo(excepciónEsperada.GetType()), "Tipo de Excepción");
              Assert.That(e.Message, Is.EqualTo(excepciónEsperada.Message), "Excepción.Message");

              lanzóExcepción = true;
            }

            Assert.That(lanzóExcepción, Is.True, "No se lanzó la excepción.");
              }
              #endregion

              #region Caso 3: Elemento con Campo Desconocido.
              {
            #region Preparación.
            // Crea elementos.
            IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
            IList<ElementoDelMapa> elementos = new List<ElementoDelMapa> {
              new ElementoDesconocido(null, 0, "Clase", new List<Campo> {
            new CampoDesconocido() })};

            const string archivoDeSalida = @"PruebaEscritorFormatoPolish.Caso3.mp";

            // Excepción esperada.
            bool lanzóExcepción = false;
            ArgumentException excepciónEsperada = new ArgumentException(
              "Campo desconocido: GpsYv.ManejadorDeMapa.Pruebas.PruebaEscritorFormatoPolish+CampoDesconocido");
            #endregion

            // Llama al constructor en prueba.
            try
            {
              new EscritorDeFormatoPolish(archivoDeSalida, elementos, escuchadorDeEstatus);
            }
            catch (Exception e)
            {
              // Prueba las propiedades de la excepción.
              Assert.That(e.GetType(), Is.EqualTo(excepciónEsperada.GetType()), "Tipo de Excepción");
              Assert.That(e.Message, Is.EqualTo(excepciónEsperada.Message), "Excepción.Message");

              lanzóExcepción = true;
            }

            Assert.That(lanzóExcepción, Is.True, "No se lanzó la excepción.");
              }
              #endregion
        }