public void TestConjuntoStrings()
{
Conjunto <String> conjuntoStrings = new Conjunto <String>("h", "e", "l", "l", "o");
Assert.AreEqual(4, conjuntoStrings.NumeroElementos,
"El constructor del conjunto funciona mal con Strings");
Assert.AreEqual("{h, e, l, o}", conjuntoStrings.ToString(),
"El constructor del conjunto funciona mal con Strings.");
conjuntoStrings.AddLast("!");
Assert.AreEqual(5, conjuntoStrings.NumeroElementos,
"El método AddLast() del conjunto funciona mal con Strings");
Assert.AreEqual("{h, e, l, o, !}", conjuntoStrings.ToString(),
"El método AddLast() del conjunto funciona mal con Strings.");
conjuntoStrings.RemoveFirst();
Assert.AreEqual(4, conjuntoStrings.NumeroElementos,
"El método RemoveFirst() del conjunto funciona mal con Strings");
Assert.AreEqual("{e, l, o, !}", conjuntoStrings.ToString(),
"El método RemoveFirst() del conjunto funciona mal con Strings.");
Assert.AreEqual("e", conjuntoStrings.Get(0),
"El método Get() del conjunto funciona mal con Strings");
Assert.AreEqual(true, conjuntoStrings.Contains("l"),
"El método Contains() del conjunto funciona mal con Strings");
Assert.AreEqual(false, conjuntoStrings.Contains("k"),
"El método Contains() del conjunto funciona mal con Strings");
}
public void TestConjuntoPersonas()
{
Conjunto <Persona> conjuntoStrings = new Conjunto <Persona>(
new Persona("Carlos", "Sanabria", "Miranda", "12345678A"));
Assert.AreEqual(1, conjuntoStrings.NumeroElementos,
"El constructor del conjunto funciona mal con Personas");
Assert.AreEqual("{Carlos Sanabria Miranda con NIF 12345678A}", conjuntoStrings.ToString(),
"El constructor del conjunto funciona mal con Personas.");
conjuntoStrings.AddLast(new Persona("Pedro", "Pérez", "Allende", "12345678B"));
Assert.AreEqual(2, conjuntoStrings.NumeroElementos,
"El método AddLast() del conjunto funciona mal con Personas");
Assert.AreEqual("{Carlos Sanabria Miranda con NIF 12345678A, " +
"Pedro Pérez Allende con NIF 12345678B}", conjuntoStrings.ToString(),
"El método AddLast() del conjunto funciona mal con Personas.");
conjuntoStrings.RemoveFirst();
Assert.AreEqual(1, conjuntoStrings.NumeroElementos,
"El método RemoveFirst() del conjunto funciona mal con Personas");
Assert.AreEqual("{Pedro Pérez Allende con NIF 12345678B}", conjuntoStrings.ToString(),
"El método RemoveFirst() del conjunto funciona mal con Personas.");
Assert.AreEqual("Pedro Pérez Allende con NIF 12345678B", conjuntoStrings.Get(0).ToString(),
"El método Get() del conjunto funciona mal con Personas");
Assert.AreEqual(true, conjuntoStrings.Contains(
new Persona("Pedro", "Pérez", "Allende", "12345678B")),
"El método Contains() del conjunto funciona mal con Personas");
Assert.AreEqual(false, conjuntoStrings.Contains(
new Persona("Luis", "Pérez", "Allende", "12345678B")),
"El método Contains() del conjunto funciona mal con Personas");
}
public void TestConjuntoDoubles()
{
Conjunto <double> conjuntoStrings = new Conjunto <double>(1.1, 2.2, 3.3);
Assert.AreEqual(3, conjuntoStrings.NumeroElementos,
"El constructor del conjunto funciona mal con doubles.");
Assert.AreEqual("{1,1, 2,2, 3,3}", conjuntoStrings.ToString(),
"El constructor del conjunto funciona mal con doubles.");
conjuntoStrings.AddLast(4.4);
Assert.AreEqual(4, conjuntoStrings.NumeroElementos,
"El método AddLast() del conjunto funciona mal con doubles.");
Assert.AreEqual("{1,1, 2,2, 3,3, 4,4}", conjuntoStrings.ToString(),
"El método AddLast() del conjunto funciona mal con doubles.");
conjuntoStrings.RemoveFirst();
Assert.AreEqual(3, conjuntoStrings.NumeroElementos,
"El método RemoveFirst() del conjunto funciona mal con doubles.");
Assert.AreEqual("{2,2, 3,3, 4,4}", conjuntoStrings.ToString(),
"El método RemoveFirst() del conjunto funciona mal con doubles.");
Assert.AreEqual(2.2, conjuntoStrings.Get(0),
"El método Get() del conjunto funciona mal con doubles.");
Assert.AreEqual(true, conjuntoStrings.Contains(3.3),
"El método Contains() del conjunto funciona mal con doubles.");
Assert.AreEqual(false, conjuntoStrings.Contains(5.5),
"El método Contains() del conjunto funciona mal con doubles.");
}
public void TestConjuntoAdd()
{
conjunto = new Conjunto <int>(0, 1, 2);
conjunto.Add(1, 4);
Assert.AreEqual(4, conjunto.NumeroElementos,
"Añadir un elemento (no repetido) en medio a un conjunto con 3 elementos no incrementa el número de elementos a 4.");
Assert.AreEqual("{0, 4, 1, 2}", conjunto.ToString(),
"La operación de añadir un 4 (no repetido) en la posición 1 no lo añade correctamente");
conjunto.Add(1, 1);
Assert.AreEqual(4, conjunto.NumeroElementos,
"Añadir un elemento (repetido) en medio a un conjunto con 4 elementos incrementa el número de elementos a 5.");
Assert.AreEqual("{0, 4, 1, 2}", conjunto.ToString(),
"La operación de añadir un 1 (repetido) en la posición 1 lo añade.");
}
public void TestConjuntoAddFirst()
{
conjunto = new Conjunto <int>(1, 2);
conjunto.AddFirst(0);
Assert.AreEqual(3, conjunto.NumeroElementos,
"Añadir un elemento (no repetido) al principio a un conjunto con 2 elementos no incrementa el número de elementos a 3.");
Assert.AreEqual("{0, 1, 2}", conjunto.ToString(),
"La operación de añadir al principio un elemento no repetido no lo añade correctamente.");
conjunto.AddFirst(2);
Assert.AreEqual(3, conjunto.NumeroElementos,
"Añadir un elemento (repetido) al principio a un conjunto incrementa el número de elementos.");
Assert.AreEqual("{0, 1, 2}", conjunto.ToString(),
"La operación de añadir al principio un elemento repetido lo añade.");
}
public void TestConjuntoConstructorUnSoloElemento()
{
conjunto = new Conjunto <int>(1);
Assert.AreEqual(1, conjunto.NumeroElementos,
"El constructor de conjunto con un elemento no crea un conjunto con 1 elemento.");
Assert.AreEqual("{1}", conjunto.ToString(),
"El constructor de conjunto con un 1 como parámetro no crea un conjunto con un 1.");
}
public void TestConjuntoConstructorArray()
{
conjunto = new Conjunto <int>(new int[] { 1, 2, 1, 3 });
Assert.AreEqual(3, conjunto.NumeroElementos,
"El constructor de conjunto con 4 elementos como parámetro (uno de ellos repetido) no crea una conjunto con 3 elementos.");
Assert.AreEqual("{1, 2, 3}", conjunto.ToString(),
"El constructor de conjunto con varios elementos como parámetro no crea un conjunto con los números 1, 2 y 3.");
}
public void TestConjuntoConstructorConjuntoVacio()
{
conjunto = new Conjunto <int>();
Assert.AreEqual(0, conjunto.NumeroElementos,
"El constructor de conjunto vacío no crea una conjunto con 0 elementos.");
Assert.AreEqual("{}", conjunto.ToString(),
"El constructor de conjunto vacío no crea una conjunto vacío.");
}
public void TestConjuntoRemoveAt()
{
conjunto = new Conjunto <int>(1, 2, 3, 4);
conjunto.RemoveAt(1);
Assert.AreEqual(3, conjunto.NumeroElementos,
"Borrar un elemento del medio de un conjunto de 4 elementos no decrementa el número de elementos a 3.");
Assert.AreEqual("{1, 3, 4}", conjunto.ToString(),
"La operación de borrar el elemento en la posición 1 no lo borra correctamente");
}
public void TestConjuntoRemoveFirst()
{
conjunto = new Conjunto <int>(1, 3, 4);
conjunto.RemoveFirst();
Assert.AreEqual(2, conjunto.NumeroElementos,
"Borrar un elemento al principio de un conjunto de 3 elementos no decrementa el número de elementos a 2.");
Assert.AreEqual("{3, 4}", conjunto.ToString(),
"La operación de borrar el elemento al principio no lo borra correctamente");
}
public void TestConjuntoRemoveLast()
{
conjunto = new Conjunto <int>(3, 4);
conjunto.RemoveLast();
Assert.AreEqual(1, conjunto.NumeroElementos,
"Borrar un elemento al final de un conjunto de 2 elementos no decrementa el número de elementos a 1.");
Assert.AreEqual("{3}", conjunto.ToString(),
"La operación de borrar el elemento al final no lo borra correctamente");
}
public void TestConjuntoOperadorMas01()
{
Conjunto <String> conjuntoStrings = new Conjunto <String>("w", "o", "r", "l");
Conjunto <String> conjuntoStrings2 = conjuntoStrings + "d";
Assert.AreEqual(5, conjuntoStrings2.NumeroElementos,
"El operador + del conjunto no incrementa el número de elementos en 1 al añadir un elemento no repetido.");
Assert.AreEqual("{w, o, r, l, d}", conjuntoStrings2.ToString(),
"El operador + del conjunto no añade el nuevo elemento (no repetido) al final del conjunto.");
// Comprobamos que conjuntoStrings no se ve modificado
Assert.AreEqual(4, conjuntoStrings.NumeroElementos,
"El operador + del conjunto modifica el conjunto sobre el que se aplica.");
Assert.AreEqual("{w, o, r, l}", conjuntoStrings.ToString(),
"El operador + del conjunto modifica el conjunto sobre el que se aplica.");
conjuntoStrings2 += "d";
Assert.AreEqual(5, conjuntoStrings2.NumeroElementos,
"El operador + del conjunto incrementa el número de elementos en 1 al añadir un elemento repetido.");
Assert.AreEqual("{w, o, r, l, d}", conjuntoStrings2.ToString(),
"El operador + del conjunto añade un elemento repetido al final del conjunto.");
}
public void TestConjuntoRemoveValue()
{
conjunto = new Conjunto <int>(1, 3, 4);
bool wasRemoved = conjunto.RemoveValue(3);
Assert.AreEqual(2, conjunto.NumeroElementos,
"Borrar usando RemoveValue() un elemento que está en el conjunto no decrementa en 1 el número de elementos.");
Assert.AreEqual(true, wasRemoved,
"Borrar usando RemoveValue() un elemento que está en el conjunto no retorna true.");
Assert.AreEqual("{1, 4}", conjunto.ToString(),
"Borrar usando RemoveValue() un elemento que está en el conjunto no lo borra correctamente.");
wasRemoved = conjunto.RemoveValue(3);
Assert.AreEqual(2, conjunto.NumeroElementos,
"Borrar usando RemoveValue() un elemento que NO está en el conjunto modifica el número de elementos.");
Assert.AreEqual(false, wasRemoved,
"Borrar usando RemoveValue() un elemento que NO está en el conjunto no retorna false.");
Assert.AreEqual("{1, 4}", conjunto.ToString(),
"Borrar usando RemoveValue() un elemento que NO está en el conjunto modifica el conjunto.");
}
public void TestConjuntoAddLast()
{
conjunto = new Conjunto <int>();
conjunto.AddLast(1);
Assert.AreEqual(1, conjunto.NumeroElementos,
"Añadir un elemento al final a un conjunto vacío no incrementa el número de elementos a 1.");
Assert.AreEqual("{1}", conjunto.ToString(),
"La operación de añadir al final un 1 no lo añade correctamente");
conjunto.AddLast(2);
Assert.AreEqual(2, conjunto.NumeroElementos,
"Añadir un elemento (no repetido) al final a un conjunto con 1 elemento no incrementa el número de elementos a 2.");
Assert.AreEqual("{1, 2}", conjunto.ToString(),
"Añadir un elemento (no repetido) al final a un conjunto con 1 elemento no lo añade correctamente.");
conjunto.AddLast(2);
Assert.AreEqual(2, conjunto.NumeroElementos,
"Añadir un elemento (repetido) al final a un conjunto incrementa el número de elementos.");
Assert.AreEqual("{1, 2}", conjunto.ToString(),
"Añadir un elemento (repetido) al final a un conjunto lo añade.");
}
public void TestConjuntoConstructorCopia()
{
Conjunto <int> conjuntoOtro = new Conjunto <int>(1, 2, 3);
conjunto = new Conjunto <int>(conjuntoOtro);
Assert.AreEqual(conjuntoOtro.NumeroElementos, conjunto.NumeroElementos,
"El conjunto creado con el constructor de copia tiene el mismo número de elementos que el conjunto original.");
Assert.AreEqual(conjuntoOtro.ToString(), conjunto.ToString(),
"El conjunto creado con el constructor de copia tiene los mismos elementos que el conjunto original.");
// Comprobamos que los dos conjuntos son totalmente independientes (modificar uno no modifica el otro)
conjuntoOtro.AddLast(4);
conjunto.RemoveFirst();
Assert.AreEqual(4, conjuntoOtro.NumeroElementos,
"El conjunto creado con el constructor de copia no es independiente del conjunto original.");
Assert.AreEqual("{1, 2, 3, 4}", conjuntoOtro.ToString(),
"El conjunto creado con el constructor de copia no es independiente del conjunto original.");
Assert.AreEqual(2, conjunto.NumeroElementos,
"El conjunto creado con el constructor de copia no es independiente del conjunto original.");
Assert.AreEqual("{2, 3}", conjunto.ToString(),
"El conjunto creado con el constructor de copia no es independiente del conjunto original.");
}
public void TestConjuntoOperadorMenos01()
{
Conjunto <String> conjuntoStrings = new Conjunto <String>("w", "o", "r", "l");
Conjunto <String> conjuntoStrings2 = conjuntoStrings - "l";
Assert.AreEqual(3, conjuntoStrings2.NumeroElementos,
"El operador - del conjunto con un elemento que está en el conjunto " +
"no decrementa el número de elementos en 1.");
Assert.AreEqual("{w, o, r}", conjuntoStrings2.ToString(),
"El operador - del conjunto con un elemento que está en el conjunto " +
"no elimina dicho elemento.");
// Comprobamos que conjuntoStrings no se ve modificado
Assert.AreEqual(4, conjuntoStrings.NumeroElementos,
"El operador - del conjunto modifica el conjunto sobre el que se aplica.");
Assert.AreEqual("{w, o, r, l}", conjuntoStrings.ToString(),
"El operador - del conjunto modifica el conjunto sobre el que se aplica.");
conjuntoStrings2 -= "l";
Assert.AreEqual(3, conjuntoStrings2.NumeroElementos,
"El operador - del conjunto con un elemento que no está en el conjunto " +
"decrementa el número de elementos en 1.");
Assert.AreEqual("{w, o, r}", conjuntoStrings2.ToString(),
"El operador - del conjunto con un elemento que no está en el conjunto modifica el conjunto.");
}
public void TestConjuntoOperadorMenos02()
{
Conjunto <String> conjuntoStrings = new Conjunto <String>("w", "o", "r", "l");
Conjunto <String> conjuntoStrings2 = conjuntoStrings - new String[] { "r", "l", "l" };
Assert.AreEqual(2, conjuntoStrings2.NumeroElementos,
"El operador - del conjunto usado con un array no decrementa el número de elementos " +
"del conjunto en el número de elementos del array que no se repiten en el conjunto.");
Assert.AreEqual("{w, o}", conjuntoStrings2.ToString(),
"El operador - del conjunto usado con un array no borra los elementos correctamente del conjunto.");
// Comprobamos que conjuntoStrings no se ve modificado
Assert.AreEqual(4, conjuntoStrings.NumeroElementos,
"El operador - del conjunto modifica el conjunto sobre el que se aplica.");
Assert.AreEqual("{w, o, r, l}", conjuntoStrings.ToString(),
"El operador - del conjunto modifica el conjunto sobre el que se aplica.");
}
public void TestConjuntoOperadorInterseccion()
{
Conjunto <int> conjunto1 = new Conjunto <int>(1, 2, 3);
Conjunto <int> conjunto2 = new Conjunto <int>(2, 3, 4);
Conjunto <int> interseccion = conjunto1 & conjunto2;
Assert.AreEqual(2, interseccion.NumeroElementos,
"El operador & del conjunto con otro conjunto no tiene el número de elementos " +
"equivalente a los elementos que aparecen en ambos conjuntos.");
Assert.AreEqual("{2, 3}", interseccion.ToString(),
"El operador & del conjunto con otro conjunto no tiene los elementos que aparecen en ambos conjuntos.");
// Comprobamos que los conjuntos iniciales no se ven modificados
Assert.AreEqual(3, conjunto1.NumeroElementos,
"El operador & modifica el primer conjunto.");
Assert.AreEqual("{1, 2, 3}", conjunto1.ToString(),
"El operador & modifica el primer conjunto.");
Assert.AreEqual(3, conjunto2.NumeroElementos,
"El operador & modifica el segundo conjunto.");
Assert.AreEqual("{2, 3, 4}", conjunto2.ToString(),
"El operador & modifica el segundo conjunto.");
}
public void TestConjuntoOperadorUnion()
{
Conjunto <int> conjunto1 = new Conjunto <int>(1, 2, 3);
Conjunto <int> conjunto2 = new Conjunto <int>(2, 3, 4);
Conjunto <int> union = conjunto1 | conjunto2;
Assert.AreEqual(4, union.NumeroElementos,
"El operador | del conjunto con otro conjunto no tiene el número de elementos " +
"equivalente a los elementos únicos de cada conjunto.");
Assert.AreEqual("{1, 2, 3, 4}", union.ToString(),
"El operador | del conjunto con otro conjunto no tiene los elementos únicos de cada conjunto.");
// Comprobamos que los conjuntos iniciales no se ven modificados
Assert.AreEqual(3, conjunto1.NumeroElementos,
"El operador | modifica el primer conjunto.");
Assert.AreEqual("{1, 2, 3}", conjunto1.ToString(),
"El operador | modifica el primer conjunto.");
Assert.AreEqual(3, conjunto2.NumeroElementos,
"El operador | modifica el segundo conjunto.");
Assert.AreEqual("{2, 3, 4}", conjunto2.ToString(),
"El operador | modifica el segundo conjunto.");
}
public void TestConjuntoOperadorDiferencia()
{
Conjunto <int> conjunto1 = new Conjunto <int>(1, 2, 3, 4, 5);
Conjunto <int> conjunto2 = new Conjunto <int>(2, 3, 4, 6);
Conjunto <int> interseccion = conjunto1 - conjunto2;
Assert.AreEqual(2, interseccion.NumeroElementos,
"El operador - del conjunto con otro conjunto no tiene el número de elementos " +
"equivalente a los elementos del primer conjunto que no aparecen en el segundo.");
Assert.AreEqual("{1, 5}", interseccion.ToString(),
"El operador - del conjunto con otro conjunto no tiene los elementos " +
"del primer conjunto que no aparecen en el segundo.");
// Comprobamos que los conjuntos iniciales no se ven modificados
Assert.AreEqual(5, conjunto1.NumeroElementos,
"El operador - modifica el primer conjunto.");
Assert.AreEqual("{1, 2, 3, 4, 5}", conjunto1.ToString(),
"El operador - modifica el primer conjunto.");
Assert.AreEqual(4, conjunto2.NumeroElementos,
"El operador - modifica el segundo conjunto.");
Assert.AreEqual("{2, 3, 4, 6}", conjunto2.ToString(),
"El operador - modifica el segundo conjunto.");
}
