public void TestListaEquals()
        {
            Lista <Persona> lista1 = new Lista <Persona>(Factoria.CrearPersonas());
            Lista <Persona> lista2 = new Lista <Persona>(Factoria.CrearPersonas());
            Lista <Persona> lista3 = lista1;
            Lista <Persona> lista4 = new Lista <Persona>(lista2);

            lista4.RemoveLast();

            // Comprobamos que indica que 2 variables que apuntan a la misma referencia lista son iguales.
            Assert.IsTrue(lista1.Equals(lista3), "El método Equals() no indica que dos listas iguales lo sean.");

            // Comprobamos que indica que 2 listas iguales lo son.
            Assert.IsTrue(lista1.Equals(lista2), "El método Equals() no indica que dos listas iguales lo sean.");

            // Comprobamos que indica que listas distintas no son iguales
            Assert.IsFalse(lista1.Equals(null),
                           "El método Equals() indica que dos listas son iguales cuando se le pasa null.");
            Assert.IsFalse(lista1.Equals(new Lista <int>()),
                           "El método Equals() indica que dos listas son iguales cuando se le pasa una lista de otro tipo.");
            Assert.IsFalse(lista1.Equals(lista4),
                           "El método Equals() indica que dos listas son iguales cuando las listas tienen distinto tamaño.");
            lista2.Set(0, null);
            Assert.IsFalse(lista1.Equals(lista2),
                           "El método Equals() indica que dos listas son iguales cuando tienen el mismo tamaño pero elementos distintos.");

            lista1.Set(0, null);
            Assert.IsTrue(lista1.Equals(lista2),
                          "El método Equals() indica que dos listas son distintas cuando tienen los mismos elementos.");
        }
        public void TestReducirPersonas()
        {
            Lista <Persona> personas = new Lista <Persona>(Factoria.CrearPersonas());

            var distribucionPersonasNombre = personas.Reducir((dict, persona) =>
            {
                if (dict.ContainsKey(persona.Nombre))
                {
                    dict[persona.Nombre]++;
                }
                else
                {
                    dict[persona.Nombre] = 1;
                }
                return(dict);
            }, new Dictionary <string, int>());

            var expectedDistribucion = new Dictionary <string, int>
            {
                { "María", 2 },
                { "Juan", 2 },
                { "Pepe", 1 },
                { "Luis", 1 },
                { "Carlos", 1 },
                { "Miguel", 1 },
                { "Cristina", 1 }
            };

            Assert.IsTrue(EqualDictionarys(expectedDistribucion, distribucionPersonasNombre),
                          "El método Reducir() no funciona correctamente.");
        }
        public void TestFiltrarPersonas()
        {
            Lista <Persona> personas = new Lista <Persona>(Factoria.CrearPersonas());

            #region FiltradoPersonasNombre

            /* Filtrado de personas por nombre */
            // Filtramos personas cuyo nombre sea María
            AssertFiltrar(personas, persona => persona.Nombre == "María", new[] { 0, 7 });
            // Filtramos personas cuyo nombre sea Juan
            AssertFiltrar(personas, persona => persona.Nombre == "Juan", new[] { 1, 8 });
            // Filtramos personas cuyo nombre sea Miguel
            AssertFiltrar(personas, persona => persona.Nombre == "Miguel", new[] { 5 });
            // Filtramos personas cuyo nombre sea uno que no está en la lista y comprobamos que devuelve un IEnumerable sin elementos
            AssertFiltrar(personas, persona => persona.Nombre == "Ricardo", new int[] { });

            #endregion

            #region FiltradoPersonasLetraDni

            /* Filtrado de personas cuyo nif termina en una letra dada */
            // Filtramos personas cuyo nif termine en la letra A
            AssertFiltrar(personas, persona => persona.Nif[persona.Nif.Length - 1] == 'A', new[] { 0, 3 });
            // Filtramos personas cuyo nif termine en la letra F
            AssertFiltrar(personas, persona => persona.Nif[persona.Nif.Length - 1] == 'F', new[] { 1, 6 });
            // Filtramos personas cuyo nif termine en la letra T
            AssertFiltrar(personas, persona => persona.Nif[persona.Nif.Length - 1] == 'T', new[] { 5 });
            // Filtramos personas cuya letra del nif sea una que no está en la lista y comprobamos que devuelve un IEnumerable sin elementos
            AssertFiltrar(personas, persona => persona.Nif[persona.Nif.Length - 1] == 'X', new int[] { });

            #endregion
        }
        public void TestMapPersonas()
        {
            Lista <Persona> personas      = new Lista <Persona>(Factoria.CrearPersonas());
            Lista <Persona> copiaPersonas = new Lista <Persona>(personas);

            var apellidosNombres = personas.Map(persona => persona.Apellido1 + ", " + persona.Nombre);

            // Comprobamos que los elementos son los esperados
            Assert.AreEqual(personas.NumeroElementos, apellidosNombres.Count(),
                            "El método Map() modifica el numero de elementos del IEnumerable.");

            var enumerator = personas.GetEnumerator();

            foreach (var apellidosNombre in apellidosNombres)
            {
                enumerator.MoveNext();
                var persona = enumerator.Current;
                Assert.AreEqual(persona.Apellido1 + ", " + persona.Nombre, apellidosNombre,
                                "El método Map() no retorna los elementos esperados");
            }

            // Comprobamos que no se modifica la lista original
            Assert.AreEqual(copiaPersonas, personas,
                            "El método Map() modifica el IEnumerable original.");
        }
        public void TestColaEquals()
        {
            ColaConcurrente <Persona> cola1 = new ColaConcurrente <Persona>(Factoria.CrearPersonas());
            ColaConcurrente <Persona> cola2 = new ColaConcurrente <Persona>(Factoria.CrearPersonas());
            ColaConcurrente <Persona> cola3 = cola1;
            ColaConcurrente <Persona> cola4 = new ColaConcurrente <Persona>(cola2);

            cola4.Extraer();

            // Comprobamos que indica que 2 variables que apuntan a la misma referencia cola son iguales.
            Assert.IsTrue(cola1.Equals(cola3), "El método Equals() no indica que dos colas iguales lo sean.");

            // Comprobamos que indica que 2 colas iguales lo son.
            Assert.IsTrue(cola1.Equals(cola2), "El método Equals() no indica que dos colas iguales lo sean.");

            // Comprobamos que indica que colas distintas no son iguales
            Assert.IsFalse(cola1.Equals(null),
                           "El método Equals() indica que dos colas son iguales cuando se le pasa null.");
            Assert.IsFalse(cola1.Equals(new ColaConcurrente <int>()),
                           "El método Equals() indica que dos colas son iguales cuando se le pasa una cola de otro tipo.");
            Assert.IsFalse(cola1.Equals(cola4),
                           "El método Equals() indica que dos colas son iguales cuando las colas tienen distinto tamaño.");
            cola2.Extraer();
            cola2.Añadir(new Persona("X", "X", "X"));
            Assert.IsFalse(cola1.Equals(cola2),
                           "El método Equals() indica que dos colas son iguales cuando tienen el mismo tamaño pero elementos distintos.");

            cola1.Extraer();
            cola1.Añadir(new Persona("X", "X", "X"));
            Assert.IsTrue(cola1.Equals(cola2),
                          "El método Equals() indica que dos colas son distintas cuando tienen los mismos elementos.");
        }
        public void TestBuscarPersonas()
        {
            Lista <Persona> personas = new Lista <Persona>(Factoria.CrearPersonas());

            #region BusquedaPersonasNombre

            /* Búsqueda de personas por nombre */
            // Buscamos la primera persona cuyo nombre sea María
            AssertBuscar(personas, persona => persona.Nombre == "María", personas.Get(0), messageElementInCollection);
            // Buscamos la primera persona cuyo nombre sea Juan
            AssertBuscar(personas, persona => persona.Nombre == "Juan", personas.Get(1), messageElementInCollection);
            // Buscamos la primera persona cuyo nombre sea Miguel
            AssertBuscar(personas, persona => persona.Nombre == "Miguel", personas.Get(5), messageElementInCollection);
            // Buscamos una persona que no está en la lista y comprobamos que devuelve default(Persona) = null
            AssertBuscar(personas, persona => persona.Nombre == "Ricardo", null, messageElementNotInCollection);

            #endregion

            #region BusquedaPersonasLetraDni

            /* Búsqueda de personas cuyo nif termina en una letra dada */
            // Buscamos la primera persona cuyo nif termine en la letra A
            AssertBuscar(personas, persona => persona.Nif[persona.Nif.Length - 1] == 'A',
                         personas.Get(0), messageElementInCollection);
            // Buscamos la primera persona cuyo nif termine en la letra F
            AssertBuscar(personas, persona => persona.Nif[persona.Nif.Length - 1] == 'F',
                         personas.Get(1), messageElementInCollection);
            // Buscamos la primera persona cuyo nif termine en la letra T
            AssertBuscar(personas, persona => persona.Nif[persona.Nif.Length - 1] == 'T',
                         personas.Get(5), messageElementInCollection);
            // Buscamos una persona que no está en la lista y comprobamos que devuelve default(Persona) = null
            AssertBuscar(personas, persona => persona.Nif[persona.Nif.Length - 1] == 'X',
                         null, messageElementNotInCollection);

            #endregion
        }