Example #1
0
        public void TestUniversidadLeer()
        {
            //Arange
            Universidad testUni1      = new Universidad();
            Universidad testUni2      = new Universidad();
            Alumno      alumnoTest1   = new Alumno(1, "Joaquin", "Calero", "37996295", Persona.ENacionalidad.Argentino, Universidad.EClases.Laboratorio);
            Alumno      alumnoTest2   = new Alumno(2, "Diego", "Maradona", "996295", Persona.ENacionalidad.Argentino, Universidad.EClases.Programacion);
            Profesor    profesorTest1 = new Profesor(1, "Dr. ", "Chapatin", "25364", Persona.ENacionalidad.Argentino);
            Profesor    profesorTest2 = new Profesor(2, "Dr. ", "Chapatin", "5364", Persona.ENacionalidad.Argentino);
            Profesor    profesorTest3 = new Profesor(3, "Dr. ", "Chapatin", "364", Persona.ENacionalidad.Argentino);
            Profesor    profesorTest4 = new Profesor(4, "Dr. ", "Chapatin", "64", Persona.ENacionalidad.Argentino);

            //Act
            testUni1 += alumnoTest1;
            testUni1 += alumnoTest2;
            testUni1 += profesorTest1;
            testUni1 += profesorTest2;
            testUni1 += profesorTest3;
            testUni1 += profesorTest4;
            testUni1 += Universidad.EClases.Programacion;

            Universidad.Guardar(testUni1);

            testUni2 = Universidad.Leer();

            //Assert
            Assert.IsNotNull(testUni2);
        }
Example #2
0
        public void CuandoEjecuto_MetodoLeerUniversidad_TestMethod()
        {
            this.CargarDatosUniversidad();
            Universidad.Guardar(universidad);
            Universidad universidadXml = Universidad.Leer();

            Assert.IsNotNull(universidadXml);
        }
 public void ArchivosExceptionTest()
 {
     try
     {
         Universidad utn = Universidad.Leer();
     }
     catch (Exception e)
     {
         Assert.IsInstanceOfType(e, typeof(ArchivosException));
     }
 }
 public void TestExceptionArchivos()
 {
     try
     {
         Universidad u1 = new Universidad();
         Universidad.Leer(u1);
     }
     catch (ArchivosException e)
     {
         Assert.IsInstanceOfType(e, typeof(ArchivosException));
     }
 }
        public void TestGuardarYLeerArchivoXML()
        {
            Universidad universidad1 = new Universidad();
            Profesor    profesor     = new Profesor(1, "Pepe", "Pepo", "12345678", Persona.ENacionalidad.Argentino);

            universidad1 += profesor;

            Universidad.Guardar(universidad1);
            Universidad universidad2 = Universidad.Leer();

            Assert.IsTrue(universidad1.Instructores[0] == universidad2.Instructores[0]);
        }
 public void ExcepcionDeArchivos()
 {
     try
     {
         Universidad u;
         u = Universidad.Leer();
         u = null;
         Universidad.Guardar(u);
     }
     catch (Exception e)
     {
         Assert.IsInstanceOfType(e, typeof(ArchivosException));
     }
 }
Example #7
0
        public void ValidaLeer()
        {
            Universidad univ = new Universidad();

            try
            {
                if (!Universidad.Leer(out univ))
                {
                    Assert.Fail("No se puedo guardar el archivo");
                }
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(Excepciones.ArchivosException));
            }
        }
Example #8
0
        public void TestLeerArchivoXml()
        {
            //arrange
            Universidad uni  = new Universidad();
            Universidad uni2 = new Universidad();
            Alumno      a1   = new Alumno(1, "Juan", "Lopez", "12234456",
                                          EntidadesAbstractas.Persona.ENacionalidad.Argentino, Universidad.EClases.Programacion,
                                          Alumno.EEstadoCuenta.Becado);
            Alumno a4 = new Alumno(4, "Miguel", "Hernandez", "92264456",
                                   EntidadesAbstractas.Persona.ENacionalidad.Extranjero, Universidad.EClases.Legislacion,
                                   Alumno.EEstadoCuenta.AlDia);
            Alumno a5 = new Alumno(5, "Carlos", "Gonzalez", "12236456",
                                   EntidadesAbstractas.Persona.ENacionalidad.Argentino, Universidad.EClases.Programacion,
                                   Alumno.EEstadoCuenta.AlDia);
            Alumno a6 = new Alumno(6, "Juan", "Perez", "12234656",
                                   EntidadesAbstractas.Persona.ENacionalidad.Argentino, Universidad.EClases.Laboratorio,
                                   Alumno.EEstadoCuenta.Deudor);
            Alumno a7 = new Alumno(7, "Joaquin", "Suarez", "91122456",
                                   EntidadesAbstractas.Persona.ENacionalidad.Extranjero, Universidad.EClases.Laboratorio,
                                   Alumno.EEstadoCuenta.AlDia);
            Alumno a8 = new Alumno(8, "Rodrigo", "Smith", "22236456",
                                   EntidadesAbstractas.Persona.ENacionalidad.Argentino, Universidad.EClases.Legislacion,
                                   Alumno.EEstadoCuenta.AlDia);
            Profesor i1 = new Profesor(1, "Juan", "Lopez", "12224458",
                                       EntidadesAbstractas.Persona.ENacionalidad.Argentino);
            Profesor i2 = new Profesor(2, "Roberto", "Juarez", "32234456",
                                       EntidadesAbstractas.Persona.ENacionalidad.Argentino);

            //act
            uni += a1;
            uni += a4;
            uni += a5;
            uni += a6;
            uni += a7;
            uni += a8;
            uni += i1;
            uni += i1;
            try
            {
                uni += Universidad.EClases.Programacion;
            }
            catch (SinProfesorException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                uni += Universidad.EClases.Laboratorio;
            }
            catch (SinProfesorException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                uni += Universidad.EClases.Legislacion;
            }
            catch (SinProfesorException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                uni += Universidad.EClases.SPD;
            }
            catch (SinProfesorException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                Universidad.Guardar(uni);
                Console.WriteLine("Archivo de Universidad guardado.");
            }
            catch (ArchivosException e)
            {
                Console.WriteLine(e.Message);
            }

            try
            {
                uni2 = Universidad.Leer();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            //assert

            Assert.AreEqual(uni2.Alumnos.Count, uni.Alumnos.Count);
        }
Example #9
0
        static void Main(string[] args)
        {
            Universidad uni = new Universidad();
            Alumno      a1  = new Alumno(1, "Juan", "Lopez", "12234456", EntidadesAbstractas.Persona.ENacionalidad.Argentino,
                                         Universidad.EClases.Programacion, Alumno.EEstadoCuenta.Becado);

            uni += a1;
            try
            {
                Alumno a2 = new Alumno(2, "Juana", "Martinez", "12234458", EntidadesAbstractas.Persona.ENacionalidad.Extranjero,
                                       Universidad.EClases.Laboratorio, Alumno.EEstadoCuenta.Deudor);
                uni += a2;
            }
            catch (NacionalidadInvalidaException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                Alumno a3 = new Alumno(3, "José", "Gutierrez", "12234456", EntidadesAbstractas.Persona.ENacionalidad.Argentino,
                                       Universidad.EClases.Programacion, Alumno.EEstadoCuenta.Becado);
                uni += a3;
            }
            catch (AlumnoRepetidoException e)
            {
                Console.WriteLine(e.Message);
            }
            Alumno a4 = new Alumno(4, "9", "Hernandez", "92264456", EntidadesAbstractas.Persona.ENacionalidad.Extranjero,
                                   Universidad.EClases.Legislacion, Alumno.EEstadoCuenta.AlDia);

            uni += a4;
            Alumno a5 = new Alumno(5, "Carlos", "Gonzalez", "12236456", EntidadesAbstractas.Persona.ENacionalidad.Argentino,
                                   Universidad.EClases.Programacion, Alumno.EEstadoCuenta.AlDia);

            uni += a5;
            Alumno a6 = new Alumno(6, "Juan", "Perez", "12234656", EntidadesAbstractas.Persona.ENacionalidad.Argentino,
                                   Universidad.EClases.Laboratorio, Alumno.EEstadoCuenta.Deudor);

            uni += a6;
            Alumno a7 = new Alumno(7, "Joaquin", "Suarez", "91122456", EntidadesAbstractas.Persona.ENacionalidad.Extranjero,
                                   Universidad.EClases.Laboratorio, Alumno.EEstadoCuenta.AlDia);

            uni += a7;
            Alumno a8 = new Alumno(8, "Rodrigo", "Smith", "22236456", EntidadesAbstractas.Persona.ENacionalidad.Argentino,
                                   Universidad.EClases.Legislacion, Alumno.EEstadoCuenta.AlDia);

            uni += a8;
            Profesor i1 = new Profesor(1, "Juan", "Lopez", "12224458", EntidadesAbstractas.Persona.ENacionalidad.Argentino);

            uni += i1;
            Profesor i2 = new Profesor(2, "Roberto", "Juarez", "32234456", EntidadesAbstractas.Persona.ENacionalidad.Argentino);

            uni += i2;
            try
            {
                uni += Universidad.EClases.Programacion;
            }
            catch (SinProfesorException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                uni += Universidad.EClases.Laboratorio;
            }
            catch (SinProfesorException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                uni += Universidad.EClases.Legislacion;
            }
            catch (SinProfesorException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                uni += Universidad.EClases.SPD;
            }
            catch (SinProfesorException e)
            {
                Console.WriteLine(e.Message);
            }
            Console.WriteLine(uni.ToString());
            Console.ReadKey();
            Console.Clear();
            try
            {
                Universidad.Guardar(uni);
                Universidad uniAux = Universidad.Leer();
                Console.WriteLine("Archivo de Universidad guardado.");
            }
            catch (ArchivosException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                int jornada = 0;
                Jornada.Guardar(uni[jornada]);
                Console.WriteLine("Archivo de Jornada {0} guardado.", jornada);
                Console.WriteLine(Jornada.Leer());
            }
            catch (ArchivosException e)
            {
                Console.WriteLine(e.Message);
            }
            Console.ReadKey();
        }
Example #10
0
        // patron idela para los test unitarios: AAA(Arrange, Act,Assert)
        public void Archivos()
        {
            Universidad uni = new Universidad();

            uni.Leer();
        }