Exemplo n.º 1
0
        /// <summary>
        /// Devuelve una variable lógica que indica si un objeto
        /// dado es igual.
        /// </summary>
        /// <param name="elObjecto">El objecto dado.</param>
        public override bool Equals(object elObjecto)
        {
            // Verifica objectos nulos y compara el tipo.
            if (elObjecto == null || (GetType() != elObjecto.GetType()))
            {
                return(false);
            }

            // Compara objecto.
            Coordenadas comparador = (Coordenadas)elObjecto;
            bool        esIgual    = (comparador == this);

            return(esIgual);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Cambia las coordenadas.
        /// </summary>
        /// <param name="lasCoordenadaNuevas">Las coordenadas nuevas.</param>
        /// <param name="elIndice">El índice de la coordenada a cambiar.</param>
        /// <param name="laRazón">La razón del cambio.</param>
        public virtual void CambiaCoordenadas(Coordenadas lasCoordenadaNuevas, int elIndice, string laRazón)
        {
            // Si no tiene Campo de Coordenadas entonces es un error.
            if (miCampoCoordenadas == CampoCoordenadas.Nulas)
            {
                throw new ArgumentException("Las coordenadas son nulas.");
            }

            // Cambia el campo.
            CampoCoordenadas nuevoCampoCoordenadas = new CampoCoordenadas(
                miCampoCoordenadas.Identificador,
                miCampoCoordenadas.Nivel,
                miCampoCoordenadas.Coordenadas);

            nuevoCampoCoordenadas.Coordenadas[elIndice] = lasCoordenadaNuevas;
            CambiaCampo(nuevoCampoCoordenadas, miCampoCoordenadas, laRazón);
            miCampoCoordenadas = nuevoCampoCoordenadas;
        }
Exemplo n.º 3
0
        /// <summary>
        /// Devuelve la distancia en metros entre dos coordenads.
        /// </summary>
        /// <param name="laPrimeraCoordenada">La primera coordenada.</param>
        /// <param name="laSegundaCoordenada">La segunda coordenada.</param>
        public static double DistanciaEnMetros(
            Coordenadas laPrimeraCoordenada,
            Coordenadas laSegundaCoordenada)
        {
            // Esta fórmula fue provista por Antonio Cincotti D'Orazio
            double diferenciaDeLatitud  = laPrimeraCoordenada.Latitud - laSegundaCoordenada.Latitud;
            double diferenciaDeLongitud = laPrimeraCoordenada.Longitud - laSegundaCoordenada.Longitud;

            double diferenciaDeLatitudEnMetros  = diferenciaDeLatitud * 60 * 1852;
            double diferenciaDeLongitudEnMetros = (diferenciaDeLongitud
                                                   * Math.Cos(laPrimeraCoordenada.Latitud * Math.PI / 180)) * 60 * 1852;

            double distanciaEnMetros = Math.Sqrt(
                (diferenciaDeLatitudEnMetros * diferenciaDeLatitudEnMetros) +
                (diferenciaDeLongitudEnMetros * diferenciaDeLongitudEnMetros));

            return(distanciaEnMetros);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Cambia las coordenadas.
        /// </summary>
        /// <param name="lasCoordenadaNuevas">Las coordenadas nuevas.</param>
        /// <param name="elIndice">El índice de la coordenada a cambiar.</param>
        /// <param name="laRazón">La razón del cambio.</param>
        public virtual void CambiaCoordenadas(Coordenadas lasCoordenadaNuevas, int elIndice,  string laRazón)
        {
            // Si no tiene Campo de Coordenadas entonces es un error.
              if (miCampoCoordenadas == CampoCoordenadas.Nulas)
              {
            throw new ArgumentException("Las coordenadas son nulas.");
              }

              // Cambia el campo.
              CampoCoordenadas nuevoCampoCoordenadas = new CampoCoordenadas(
            miCampoCoordenadas.Identificador,
            miCampoCoordenadas.Nivel,
            miCampoCoordenadas.Coordenadas);
              nuevoCampoCoordenadas.Coordenadas[elIndice] = lasCoordenadaNuevas;
              CambiaCampo(nuevoCampoCoordenadas, miCampoCoordenadas, laRazón);
              miCampoCoordenadas = nuevoCampoCoordenadas;
        }
Exemplo n.º 5
0
        /// <summary>
        /// Devuelve la distancia en metros entre dos coordenads.
        /// </summary>
        /// <param name="laPrimeraCoordenada">La primera coordenada.</param>
        /// <param name="laSegundaCoordenada">La segunda coordenada.</param>
        public static double DistanciaEnMetros(
            Coordenadas laPrimeraCoordenada,
            Coordenadas laSegundaCoordenada)
        {
            // Esta fórmula fue provista por Antonio Cincotti D'Orazio
              double diferenciaDeLatitud = laPrimeraCoordenada.Latitud - laSegundaCoordenada.Latitud;
              double diferenciaDeLongitud = laPrimeraCoordenada.Longitud - laSegundaCoordenada.Longitud;

              double diferenciaDeLatitudEnMetros = diferenciaDeLatitud * 60 * 1852;
              double diferenciaDeLongitudEnMetros = (diferenciaDeLongitud
            * Math.Cos(laPrimeraCoordenada.Latitud * Math.PI / 180)) * 60 * 1852;

              double distanciaEnMetros = Math.Sqrt(
            (diferenciaDeLatitudEnMetros * diferenciaDeLatitudEnMetros) +
            (diferenciaDeLongitudEnMetros * diferenciaDeLongitudEnMetros));

              return distanciaEnMetros;
        }
        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
        }