public TodoRepository(IGenericList <TodoItem> initialDbState = null)
{
_inMemoryTodoDatabase = initialDbState ?? new GenericList <TodoItem>();
// Shorter way to write this in C# using ?? operator :
// x ?? y = > if x is not null , expression returns x. Else it will return y.
// _inMemoryTodoDatabase = initialDbState ?? new List < TodoItem >();
}
private static void Print <T>(IGenericList <T> genericList, string title = "Generic List")
{
Console.WriteLine(
"-> " + title
+ Environment.NewLine
+ genericList
+ Environment.NewLine);
}
public TodoRepository(IGenericList <TodoItem> initialDbState = null)
{
if (initialDbState != null)
{
_inMemoryTodoDatabase = initialDbState;
}
else
{
_inMemoryTodoDatabase = new GenericList <TodoItem>();
}
}
public GenericListEnumerator(IGenericList <T> list)
{
_internalStorage = new T[list.Count];
for (var index = 0; index < list.Count; ++index)
{
_internalStorage[index] = list.GetElement(index);
}
_index = -1;
_disposed = false;
}
public void ListExample(IGenericList <float> list)
{
list.Add(2);
list.Add(3);
Console.WriteLine(list);
list.Add(4);
list.Add(5);
list.RemoveAt(0);
Console.WriteLine(list);
Console.WriteLine(list.Count);
Console.ReadLine();
}
public static T Minimum <T>(this IGenericList <T> list) where T : IComparable <T>
{
var minItem = list[0];
for (var i = 1; i < list.Size; i++)
{
if (list[i].CompareTo(minItem) < 0)
{
minItem = list[i];
}
}
return(minItem);
}
public static void ListExampleGenerics(IGenericList <string> listOfGenerics)
{
listOfGenerics.Add("a"); // [a]
listOfGenerics.Add("b"); // [a,b]
listOfGenerics.Add("car"); // [a,b,car]
listOfGenerics.Add("house"); // [a,b,car,house]
listOfGenerics.Add("roof"); // [a,b,car,house,roof]
listOfGenerics.RemoveAt(0); // [b,car,house,roof]
listOfGenerics.Remove("house"); //[b,car,house]
Console.WriteLine(listOfGenerics.Count); // 3
Console.WriteLine(listOfGenerics.Remove("nonExistingWord")); // false
Console.WriteLine(listOfGenerics.RemoveAt(5)); // false
listOfGenerics.Clear(); // []
Console.WriteLine(listOfGenerics.Count); // 0
}
public static void ListExample(IGenericList <int> listOfIntegers)
{
listOfIntegers.Add(1); // [1]
listOfIntegers.Add(2); // [1 ,2]
listOfIntegers.Add(3); // [1 ,2 ,3]
listOfIntegers.Add(4); // [1 ,2 ,3 ,4]
listOfIntegers.Add(5); // [1 ,2 ,3 ,4 ,5]
listOfIntegers.RemoveAt(0); // [2 ,3 ,4 ,5]
listOfIntegers.Remove(5); //[2 ,3 ,4]
Console.WriteLine(listOfIntegers.Count); // 3
Console.WriteLine(listOfIntegers.Remove(100)); // false
Console.WriteLine(listOfIntegers.RemoveAt(5)); // false
listOfIntegers.Clear(); // []
Console.WriteLine(listOfIntegers.Count); // 0
}
public static void ListExample(IGenericList <string> list)
{
list.Add("1a");
list.Add("2b");
list.Add("3c");
list.Add("4d");
list.Add("5e");
list.RemoveAt(0);
list.Remove("5e");
WriteLine(list.GetElement(2));
WriteLine(list.Count);
WriteLine(list.Remove("100"));
WriteLine(list.RemoveAt(5));
list.Clear();
WriteLine(list.Count);
}
public static void ListOfExamples(IGenericList <double> listOfIntegers)
{
listOfIntegers.Add(1.3); // [1]
listOfIntegers.Add(2.2); // [1 ,2]
listOfIntegers.Add(3.4); // [1 ,2 ,3]
listOfIntegers.Add(4.5); // [1 ,2 ,3 ,4]
listOfIntegers.Add(5.2); // [1 ,2 ,3 ,4 ,5]
listOfIntegers.RemoveAt(0); // [2 ,3 ,4 ,5]
listOfIntegers.Remove(5.2);
Console.WriteLine(listOfIntegers.Count); // 3
Console.WriteLine(listOfIntegers.Remove(100)); // false
Console.WriteLine(listOfIntegers.RemoveAt(5)); // false
listOfIntegers.Clear(); // []
Console.WriteLine(listOfIntegers.Count); // 0
Console.ReadLine();
}
public void ListExample(IGenericList <string> list)
{
list.Add("Hello");
list.Add("World");
list.Add("!");
foreach (string value in list)
{
Console.WriteLine(value);
}
//IEnumerator<string> enumerator = list.GetEnumerator();
// while(enumerator.MoveNext())
// {
// string value = (string)enumerator.Current;
// Console.WriteLine(value);
// }
}
public void TestAdd()
{
this._list = new GenericList<String>();
this._list.Add(VALUE_A);
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(1, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_A);
this._list.Add(VALUE_B);
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(2, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_A);
Assert.AreEqual(this._list.Get(1), VALUE_B);
this._list.Add(VALUE_C);
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(3, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_A);
Assert.AreEqual(this._list.Get(1), VALUE_B);
Assert.AreEqual(this._list.Get(2), VALUE_C);
}
public void Shuffle()
{
_cards = ShuffleList(_cards);
}
private IGenericList<ICard> ShuffleList(IGenericList<ICard> inputList)
{
var randomList = new GenericList<ICard>();
Random r = new Random();
int randomIndex = 0;
while (inputList.Count > 0)
{
randomIndex = r.Next(0, inputList.Count); //Choose a random object in the list
randomList.Add(inputList[randomIndex]); //add it to the new, random list
inputList.RemoveAt(randomIndex); //remove to avoid duplicates
}
return randomList; //return the new random list
}
public void Count(IGenericList<ICard> cards)
{
cards.ForEach(c => Count(c));
}
Deck(IGenericList<ICard> cards)
{
_cards = cards;
}
public GenericListEnumerator(IGenericList <T> genericList)
{
_genericList = genericList;
}
public void Dispose()
{
_genericList = null;
_position = 0;
}
public void TestDeleteByIndex()
{
this._list = new GenericList<String>();
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
try
{
this._list.Delete(-1);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
try
{
this._list.Delete(0);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
try
{
this._list.Delete(1);
}
catch (IndexOutOfRangeException)
{
//expected
}
this._list.Add(VALUE_A);
this._list.Add(VALUE_B);
this._list.Add(VALUE_C);
this._list.Add(VALUE_D);
this._list.Add(VALUE_E);
this._list.Add(VALUE_F);
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(6, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_A);
Assert.AreEqual(this._list.Get(1), VALUE_B);
Assert.AreEqual(this._list.Get(2), VALUE_C);
Assert.AreEqual(this._list.Get(3), VALUE_D);
Assert.AreEqual(this._list.Get(4), VALUE_E);
Assert.AreEqual(this._list.Get(5), VALUE_F);
Assert.AreEqual(this._list.Delete(5), VALUE_F);
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(5, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_A);
Assert.AreEqual(this._list.Get(1), VALUE_B);
Assert.AreEqual(this._list.Get(2), VALUE_C);
Assert.AreEqual(this._list.Get(3), VALUE_D);
Assert.AreEqual(this._list.Get(4), VALUE_E);
Assert.AreEqual(VALUE_A, this._list.Delete(0));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(4, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_B);
Assert.AreEqual(this._list.Get(1), VALUE_C);
Assert.AreEqual(this._list.Get(2), VALUE_D);
Assert.AreEqual(this._list.Get(3), VALUE_E);
Assert.AreEqual(VALUE_D, this._list.Delete(2));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(3, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_B);
Assert.AreEqual(this._list.Get(1), VALUE_C);
Assert.AreEqual(this._list.Get(2), VALUE_E);
Assert.AreEqual(VALUE_C, this._list.Delete(1));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(2, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_B);
Assert.AreEqual(this._list.Get(1), VALUE_E);
Assert.AreEqual(VALUE_B, this._list.Delete(0));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(1, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_E);
Assert.AreEqual(VALUE_E, this._list.Delete(0));
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
}
public GenericListController(IGenericList genericList) =>
public GenericListEnumerator(IGenericList <X> list)
{
_list = list;
}
public void TestSet()
{
this._list = new GenericList<String>();
try
{
this._list.Set(-1, VALUE_A);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
try
{
this._list.Set(0, VALUE_A);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
try
{
this._list.Set(1, VALUE_A);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
this._list.Add(VALUE_A);
try
{
this._list.Set(-1, VALUE_A);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(1, this._list.Size());
Assert.AreEqual(VALUE_A, this._list.Get(0));
try
{
this._list.Set(1, VALUE_A);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(1, this._list.Size());
Assert.AreEqual(VALUE_A, this._list.Get(0));
this._list.Add(VALUE_A);
this._list.Add(VALUE_B);
this._list.Add(VALUE_C);
this._list.Add(VALUE_B);
Assert.AreEqual(VALUE_A, this._list.Set(0, VALUE_F));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(5, this._list.Size());
Assert.AreEqual(VALUE_F, this._list.Get(0));
Assert.AreEqual(VALUE_A, this._list.Get(1));
Assert.AreEqual(VALUE_B, this._list.Get(2));
Assert.AreEqual(VALUE_C, this._list.Get(3));
Assert.AreEqual(VALUE_B, this._list.Get(4));
Assert.AreEqual(VALUE_B, this._list.Set(2, VALUE_F));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(5, this._list.Size());
Assert.AreEqual(VALUE_F, this._list.Get(0));
Assert.AreEqual(VALUE_A, this._list.Get(1));
Assert.AreEqual(VALUE_F, this._list.Get(2));
Assert.AreEqual(VALUE_C, this._list.Get(3));
Assert.AreEqual(VALUE_B, this._list.Get(4));
Assert.AreEqual(VALUE_B, this._list.Set(4, VALUE_F));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(5, this._list.Size());
Assert.AreEqual(VALUE_F, this._list.Get(0));
Assert.AreEqual(VALUE_A, this._list.Get(1));
Assert.AreEqual(VALUE_F, this._list.Get(2));
Assert.AreEqual(VALUE_C, this._list.Get(3));
Assert.AreEqual(VALUE_F, this._list.Get(4));
Assert.AreEqual(VALUE_A, this._list.Set(1, VALUE_F));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(5, this._list.Size());
Assert.AreEqual(VALUE_F, this._list.Get(0));
Assert.AreEqual(VALUE_F, this._list.Get(1));
Assert.AreEqual(VALUE_F, this._list.Get(2));
Assert.AreEqual(VALUE_C, this._list.Get(3));
Assert.AreEqual(VALUE_F, this._list.Get(4));
Assert.AreEqual(VALUE_C, this._list.Set(3, VALUE_F));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(5, this._list.Size());
Assert.AreEqual(VALUE_F, this._list.Get(0));
Assert.AreEqual(VALUE_F, this._list.Get(1));
Assert.AreEqual(VALUE_F, this._list.Get(2));
Assert.AreEqual(VALUE_F, this._list.Get(3));
Assert.AreEqual(VALUE_F, this._list.Get(4));
}
public GenericListEnumerator(IGenericList <X> collection)
{
_list = collection;
}
public TodoRepository(IGenericList <TodoItem> initalDbState = null)
{
_inMemoryToDoDatabase = initalDbState ?? new GenericList <TodoItem>();
}
public TodoRepository()
{
_inMemoryTodoDatabase = new GenericList <TodoItem>();
}
public void TestDeleteByValue()
{
this._list = new GenericList<String>();
Assert.IsFalse(this._list.Delete(VALUE_A));
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
this._list.Add(VALUE_A);
this._list.Add(VALUE_B);
this._list.Add(VALUE_A);
this._list.Add(VALUE_C);
Assert.IsFalse(this._list.Delete(VALUE_F));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(4, this._list.Size());
Assert.AreEqual(VALUE_A, this._list.Get(0));
Assert.AreEqual(VALUE_B, this._list.Get(1));
Assert.AreEqual(VALUE_A, this._list.Get(2));
Assert.AreEqual(VALUE_C, this._list.Get(3));
Assert.IsTrue(this._list.Delete(VALUE_A));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(3, this._list.Size());
Assert.AreEqual(VALUE_B, this._list.Get(0));
Assert.AreEqual(VALUE_A, this._list.Get(1));
Assert.AreEqual(VALUE_C, this._list.Get(2));
Assert.IsTrue(this._list.Delete(VALUE_C));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(2, this._list.Size());
Assert.AreEqual(VALUE_B, this._list.Get(0));
Assert.AreEqual(VALUE_A, this._list.Get(1));
Assert.IsTrue(this._list.Delete(VALUE_B));
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(1, this._list.Size());
Assert.AreEqual(VALUE_A, this._list.Get(0));
Assert.IsTrue(this._list.Delete(VALUE_A));
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
Assert.IsFalse(this._list.Delete(VALUE_A));
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
}
public TodoRepository(int initialSize)
{
_inMemoryTodoDatabase = new GenericList <TodoItem>(initialSize);
}
public void TestIndexOfAndCOntains()
{
this._list = new GenericList<String>();
Assert.IsFalse(this._list.Contains(VALUE_A));
Assert.AreEqual(-1, this._list.IndexOf(VALUE_A));
this._list.Add(VALUE_A);
Assert.IsTrue(this._list.Contains(VALUE_A));
Assert.AreEqual(0, this._list.IndexOf(VALUE_A));
Assert.IsFalse(this._list.Contains(VALUE_B));
Assert.AreEqual(-1, this._list.IndexOf(VALUE_B));
Assert.IsFalse(this._list.Contains(VALUE_C));
Assert.AreEqual(-1, this._list.IndexOf(VALUE_C));
this._list.Add(VALUE_B);
Assert.IsTrue(this._list.Contains(VALUE_A));
Assert.AreEqual(0, this._list.IndexOf(VALUE_A));
Assert.IsTrue(this._list.Contains(VALUE_B));
Assert.AreEqual(1, this._list.IndexOf(VALUE_B));
Assert.IsFalse(this._list.Contains(VALUE_C));
Assert.AreEqual(-1, this._list.IndexOf(VALUE_C));
this._list.Insert(0, VALUE_C);
Assert.IsTrue(this._list.Contains(VALUE_C));
Assert.AreEqual(0, this._list.IndexOf(VALUE_C));
Assert.IsTrue(this._list.Contains(VALUE_A));
Assert.AreEqual(1, this._list.IndexOf(VALUE_A));
Assert.IsTrue(this._list.Contains(VALUE_B));
Assert.AreEqual(2, this._list.IndexOf(VALUE_B));
this._list.Clear();
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
Assert.IsFalse(this._list.Contains(VALUE_A));
Assert.AreEqual(-1, this._list.IndexOf(VALUE_A));
Assert.IsFalse(this._list.Contains(VALUE_B));
Assert.AreEqual(-1, this._list.IndexOf(VALUE_B));
Assert.IsFalse(this._list.Contains(VALUE_C));
Assert.AreEqual(-1, this._list.IndexOf(VALUE_C));
}
public void TestListGrowsBeyondInitialSize()
{
this._list = new GenericList<String>();
for (int i = 0; i < 20; i++)
{
this._list.Add(VALUE_A);
}
for (int i = 0; i < 20; i++)
{
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(20, this._list.Size());
Assert.AreEqual(this._list.Get(i), VALUE_A);
}
}
public GenericListEnumerator(IGenericList <T> collection)
{
_collection = collection;
}
public void TestInsert()
{
this._list = new GenericList<String>();
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
try
{
this._list.Insert(-1, VALUE_A);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
try
{
this._list.Insert(1, VALUE_A);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
try
{
this._list.Get(-1);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
try
{
this._list.Get(0);
}
catch (IndexOutOfRangeException)
{
}
Assert.IsTrue(this._list.IsEmpty());
Assert.AreEqual(0, this._list.Size());
try
{
this._list.Get(1);
}
catch (IndexOutOfRangeException)
{
//expected
}
this._list.Insert(0, VALUE_A);
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(1, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_A);
this._list.Insert(1, VALUE_B);
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(2, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_A);
Assert.AreEqual(this._list.Get(1), VALUE_B);
this._list.Insert(2, VALUE_C);
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(3, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_A);
Assert.AreEqual(this._list.Get(1), VALUE_B);
Assert.AreEqual(this._list.Get(2), VALUE_C);
this._list.Insert(0, VALUE_D);
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(4, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_D);
Assert.AreEqual(this._list.Get(1), VALUE_A);
Assert.AreEqual(this._list.Get(2), VALUE_B);
Assert.AreEqual(this._list.Get(3), VALUE_C);
this._list.Insert(2, VALUE_E);
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(5, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_D);
Assert.AreEqual(this._list.Get(1), VALUE_A);
Assert.AreEqual(this._list.Get(2), VALUE_E);
Assert.AreEqual(this._list.Get(3), VALUE_B);
Assert.AreEqual(this._list.Get(4), VALUE_C);
try
{
this._list.Insert(-1, VALUE_A);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(5, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_D);
Assert.AreEqual(this._list.Get(1), VALUE_A);
Assert.AreEqual(this._list.Get(2), VALUE_E);
Assert.AreEqual(this._list.Get(3), VALUE_B);
Assert.AreEqual(this._list.Get(4), VALUE_C);
try
{
this._list.Insert(6, VALUE_A);
}
catch (IndexOutOfRangeException)
{
//expected
}
Assert.IsFalse(this._list.IsEmpty());
Assert.AreEqual(5, this._list.Size());
Assert.AreEqual(this._list.Get(0), VALUE_D);
Assert.AreEqual(this._list.Get(1), VALUE_A);
Assert.AreEqual(this._list.Get(2), VALUE_E);
Assert.AreEqual(this._list.Get(3), VALUE_B);
Assert.AreEqual(this._list.Get(4), VALUE_C);
}
