Exemplo n.º 1
0
        static void Main(string[] args)
        {
            string directorioDeEntrada;
              string directorioDeSalida;

              #region Selecciona el directorio de entrada.
              using (FolderBrowserDialog ventanaDeDirectorios = new FolderBrowserDialog())
              {
            ventanaDeDirectorios.Description = "Selecciona el directorio con las fuentes:";
            ventanaDeDirectorios.ShowNewFolderButton = false;
            ventanaDeDirectorios.SelectedPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase);
            DialogResult respuesta = ventanaDeDirectorios.ShowDialog();

            // Nos salimos si el usuario cancela.
            if (respuesta != DialogResult.OK)
            {
              Console.WriteLine("Cancelado por el usuario.");
              Environment.Exit(1);
            }

            directorioDeEntrada = ventanaDeDirectorios.SelectedPath;
            Console.WriteLine(string.Format("Directorio con las fuentes: {0}", directorioDeEntrada));
              }
              #endregion

              #region Selecciona el directorio de salida.
              using (FolderBrowserDialog ventanaDeDirectorios = new FolderBrowserDialog())
              {
            ventanaDeDirectorios.Description = "Selecciona el directorio de salida:";
            ventanaDeDirectorios.ShowNewFolderButton = true;
            DialogResult respuesta = ventanaDeDirectorios.ShowDialog();

            // Nos salimos si el usuario cancela.
            if (respuesta != DialogResult.OK)
            {
              Console.WriteLine("Cancelado por el usuario.");
              Environment.Exit(1);
            }

            directorioDeSalida = ventanaDeDirectorios.SelectedPath;
            Console.WriteLine(string.Format("Directorio de Salida: {0}", directorioDeSalida));
              }
              #endregion

              // Chequea que los directorios no sean los mismos.
              if (directorioDeEntrada == directorioDeSalida)
              {
            Console.WriteLine("ERROR: El directorio de entrada y salida deben ser diferentes.");
            Environment.Exit(1);
              }

              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa.ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa.ManejadorDeMapa(escuchadorDeEstatus);
              RemplazadorDeLetrasEspeciales remplazadorDeLetrasEspeciales = new RemplazadorDeLetrasEspeciales(
            manejadorDeMapa.ManejadorDeElementos,
            escuchadorDeEstatus);

              DirectoryInfo informaciónDelDirectorio = new DirectoryInfo(directorioDeEntrada);
              FileInfo[] archivosFuente = informaciónDelDirectorio.GetFiles("*.mp");

              foreach (FileInfo archivo in archivosFuente)
              {
            Console.WriteLine(string.Format("Procesando '{0}' ... ", archivo.FullName));
            Console.WriteLine();

            // Lee mapa.
            Console.Write("Leyendo mapa ... ");
            manejadorDeMapa.Abrir(archivo.FullName);
            Console.WriteLine("listo.");

            // Remplaza las letras especiales.
            Console.Write("Cambiando caracteres ... ");
            int número = remplazadorDeLetrasEspeciales.Procesa();
            Console.WriteLine(string.Format(" cambiados {0} nombres", número));

            // Verifica que el archivo de salida no existe.
            string archivoDeSalida = Path.Combine(directorioDeSalida, archivo.Name);
            if (File.Exists(archivoDeSalida))
            {
              DialogResult respuesta = MessageBox.Show(
            string.Format("El archivo de salida '{0}' existe. El directorio de salida debe estar vacio. El programa terminará.", archivoDeSalida),
            "Archivo de Salida",
            MessageBoxButtons.OK,
            MessageBoxIcon.Error);

              Console.WriteLine("Archivo de salida existe.");
              Environment.Exit(1);
              break;
            }

            // Escribe el archivo de salida.
            Console.Write(string.Format("Guardando mapa '{0}' ... ", archivoDeSalida));
            manejadorDeMapa.GuardaEnFormatoPolish(
              archivoDeSalida,
              string.Format("Generado por {0} @ {1}", Assembly.GetExecutingAssembly().GetName().Name, DateTime.Now));
            Console.WriteLine("listo.");
            Console.WriteLine();
              }
        }
        public void PruebaShowDialog()
        {
            #region Preparación general.
              // Crea un PDI para las pruebas.
              IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
              ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
              string nombre = "Nombre";
              Tipo tipo = new Tipo("0xaaaa");
              const string clase = "POI";
              Coordenadas coordenadas = new Coordenadas(20, 30);
              List<Campo> campos = new List<Campo> {
              new CampoNombre (nombre),
              new CampoTipo (tipo),
              new CampoCoordenadas (CampoCoordenadas.IdentificadorDeCoordenadas, 0, coordenadas)
            };
              List<Pdi> pdis = new List<Pdi>{new Pdi(manejadorDeMapa, 1, clase, campos)};
              #endregion

              #region Caso 1: Apenas aparece la ventana el usuario apreta "Cambiar"
              {
            // En este caso el método Show() debería retornar None,
            // Y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Apreta el botón de "Cambiar".
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.None, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 2: Apenas aparece la ventana el usuario apreta "Cancelar"
              {
            // En este caso el método Show() debería retornar Cancel,
            // Y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCancelar = new ButtonTester("miBotónCancelar", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Apreta el botón de "Cancelar".
            botónCancelar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.Cancel, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 3: El usuario cambia el tipo inicial por uno válido.
              {
            // En este caso el método Show() debería retornar OK,
            // y la propiedad TipoNuevo debería ser el tipo nuevo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea un tipo válido.
            string númeroTipoNuevoVálido = "100";
            Tipo tipoNuevoVálido = new Tipo("0x" + númeroTipoNuevoVálido);
            Assert.IsTrue(CaracterísticasDePdis.Descripciones.ContainsKey(tipoNuevoVálido), "El tipo nuevo debe ser conocido.");

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario poniendo un tipo válido.
            textoTipoNuevo.Properties.Focus();
            textoTipoNuevo.Enter(númeroTipoNuevoVálido);

            // Apreta el botón de "Cambiar".
            botónCambiar.Properties.Focus();
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.OK, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(tipoNuevoVálido, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 4: El usuario cambia el tipo inicial por uno desconocido.
              {
            // En este caso el método Show() debería retornar None,
            // y la propiedad TipoNuevo debería ser el tipo desconocido.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea un tipo desconocido.
            string númeroTipoNuevoDesconocido = "bbbb";
            Tipo tipoNuevoDesconocido = new Tipo("0x" + númeroTipoNuevoDesconocido);
            Assert.IsFalse(CaracterísticasDePdis.Descripciones.ContainsKey(tipoNuevoDesconocido), "El tipo nuevo debe ser desconocido.");

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario poniendo un tipo desconocido.
            textoTipoNuevo.Properties.Focus();
            textoTipoNuevo.Enter(númeroTipoNuevoDesconocido);

            // Apreta el botón de "Cambiar".
            botónCambiar.Properties.Focus();
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.None, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(tipoNuevoDesconocido, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 5: El usuario cambia el tipo inicial por uno inválido.
              {
            // En este caso el método Show() debería retornar None,
            // y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea un tipo inválido.
            // Un tipo inválido es aquel que genera una excepción cuando
            // se trata de construir una clase Tipo con el.
            string númeroTipoNuevoInválido = "ww";
            bool tipoEsInválido = false;
            try
            {
              new Tipo("0x" + númeroTipoNuevoInválido);
            }
            catch
            {
              tipoEsInválido = true;
            }
            Assert.IsTrue(tipoEsInválido, "El tipo nuevo debe ser inválido.");

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario poniendo un tipo inválido.
            textoTipoNuevo.Properties.Focus();
            textoTipoNuevo.Enter(númeroTipoNuevoInválido);

            // Apreta el botón de "Cambiar".
            botónCambiar.Properties.Focus();
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.None, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 6: El usuario empiezar a cambiar el tipo, pero al final lo borra y lo deja en blanco.
              {
            // En este caso el método Show() debería retornar None,
            // y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario empezando a cambiar el tipo y despues dejandolo en blanco.
            textoTipoNuevo.Properties.Focus();
            textoTipoNuevo.Enter("123");
            textoTipoNuevo.Properties.Text = string.Empty;

            // Apreta el botón de "Cambiar".
            botónCambiar.Properties.Focus();
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.None, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");
            Assert.AreEqual(pdis, objectoDePrueba.Pdis, "PDIs");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 7: El usuario empiezar a cambiar el tipo, pero al final cancela.
              {
            // En este caso el método Show() debería retornar Cancel,
            // y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = pdis;

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCancelar = new ButtonTester("miBotónCancelar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario empezando a cambiar el tipo y despues dejandolo en blanco.
            textoTipoNuevo.Enter("123");
            textoTipoNuevo.Properties.Text = string.Empty;

            // Apreta el botón de "Cancelar".
            botónCancelar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.Cancel, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion

              #region Caso 8: Se usa con un PDI nulo.
              {
            // En este caso el método Show() debería retornar None,
            // y la propiedad TipoNuevo debería ser el tipo nulo.

            #region Preparación.
            // Inicializa objecto de prueba.
            VentanaCambiarTipoDePdi objectoDePrueba = new VentanaCambiarTipoDePdi();
            objectoDePrueba.Pdis = null;

            // Crea los probadores de los elementos de la interfase.
            ButtonTester botónCambiar = new ButtonTester("miBotónCambiar", objectoDePrueba);
            TextBoxTester textoTipoNuevo = new TextBoxTester("miTextoTipoNuevo", objectoDePrueba);
            #endregion

            // Llama al método a probar.
            objectoDePrueba.Show();

            // Simula el usuario empezando a cambiar el tipo y despues dejandolo en blanco.
            textoTipoNuevo.Properties.Focus();
            textoTipoNuevo.Enter("100");
            textoTipoNuevo.Properties.Text = string.Empty;

            // Apreta el botón de "Cambiar".
            botónCambiar.Properties.Focus();
            botónCambiar.Click();

            // Probar propiedades.
            Assert.AreEqual(DialogResult.None, objectoDePrueba.DialogResult, "DialogResult");
            Assert.AreEqual(Tipo.TipoNulo, objectoDePrueba.TipoNuevo, "TipoNuevo");

            // Cierra la ventana.
            objectoDePrueba.Close();
              }
              #endregion
        }