public void CoverWillOnlyRemoveRowsFromLinkedColumns()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeaders(root, EXPECTED_LENGTH);
Node[] nodes = new Node[EXPECTED_LENGTH / 2];
for (int i = 0; i < EXPECTED_LENGTH; i++)
{
Node created = headers[i].CreateNode();
if (i % 2 == 0)
{
nodes[i / 2] = created;
}
}
Node.LinkNodes(nodes);
headers[0].Cover();
int sum = 0;
ColumnHeader next = root.right;
while (next != root)
{
sum += next.Size;
next = next.right;
}
Assert.IsTrue(sum == EXPECTED_LENGTH / 2);
}
public void RemoveRowSetsOtherHeadersHeightsCorrectly()
{
HeaderRoot root = GetRoot();
ColumnHeader headerSingle = new ColumnHeader(root);
ColumnHeader otherHeader = new ColumnHeader(root);
ColumnHeader otherHeader2 = new ColumnHeader(root);
Node toRemove = headerSingle.CreateNode();
Node linked = otherHeader.CreateNode();
Node linkedH2 = otherHeader2.CreateNode();
Node.LinkNodes(toRemove, linked, linkedH2);
Node linked2 = otherHeader.CreateNode();
Node toRemove2 = otherHeader2.CreateNode();
Node.LinkNodes(toRemove2, linked2);
otherHeader.CreateNode();
otherHeader.CreateNode();
toRemove.RemoveRow();
toRemove2.RemoveRow();
Assert.IsTrue(headerSingle.Size == 1);
Assert.IsTrue(otherHeader.Size == 2);
Assert.IsTrue(otherHeader2.Size == 1);
}
public void LinkedHeadersCountedCorrectly()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeaders(root, EXPECTED_LENGTH);
Assert.IsTrue(root.Count == EXPECTED_LENGTH);
}
public void CoverWorksWithNoNodes()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeaders(root, EXPECTED_LENGTH);
headers[0].Cover();
Assert.IsTrue(root.Count == EXPECTED_LENGTH - 1);
}
private Node[] GetKnownProblemSolutionNodes(HeaderRoot root)
{
Node[] solutionSet = new Node[SolutionNodeCount];
solutionSet[0] = root[0].down.down;
solutionSet[1] = root[4].down.down;
solutionSet[2] = root[1].down.down;
return(solutionSet);
}
public void HidingRemovesHeaderFromLinkedList()
{
HeaderRoot root = GetRoot();
ColumnHeader next = new ColumnHeader(root);
next.Hide();
Assert.IsTrue(root.Count == 0);
}
private ColumnHeader[] GetHeaders(HeaderRoot root, int numHeaders)
{
ColumnHeader[] newHeaders = new ColumnHeader[numHeaders];
for (int i = 0; i < numHeaders; i++)
{
newHeaders[i] = root.CreateHeader();
}
return(newHeaders);
}
public void SearchWillReturnACorrectNodeSolutionStack()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeadersWithLinkedNodes(root);
Stack <Node> solution = root.Search();
Assert.IsTrue(solution.Count == 1);
}
/// <summary>
/// Creates and links nodes that exist at the given header indexes.
/// </summary>
/// <param name="root"></param>
/// <param name="headerIndexes">These are expected to be 1 indexed.</param>
private void CreateRowForHeaders(HeaderRoot root, params int[] headerIndexes)
{
Node[] toLink = new Node[headerIndexes.Length];
for (int i = 0; i < headerIndexes.Length; i++)
{
toLink[i] = root[headerIndexes[i] - 1].CreateNode();
}
Node.LinkNodes(toLink);
}
private ColumnHeader GetHeaderAt(HeaderRoot root, int index)
{
ColumnHeader currHeader = root.right;
for (int i = 0; i < index; i++)
{
currHeader = currHeader.right;
}
return(currHeader);
}
public void HeaderAsConstructionParameterLinksHeadersTogether()
{
HeaderRoot root = GetRoot();
ColumnHeader next = new ColumnHeader(root);
Assert.IsTrue(root == next.left);
Assert.IsTrue(next.right == root);
Assert.IsFalse(root.Equals(next.up));
Assert.IsFalse(root.Equals(next.down));
}
private ColumnHeader[] GetKnownProblemHeaders(HeaderRoot root)
{
ColumnHeader[] headers = GetHeaders(root, NUM_HEADERS_FOR_KNOWN_MATRIX);
CreateRowForHeaders(root, 1, 4, 7);
CreateRowForHeaders(root, 1, 4);
CreateRowForHeaders(root, 4, 5, 7);
CreateRowForHeaders(root, 3, 5, 6);
CreateRowForHeaders(root, 2, 3, 6, 7);
CreateRowForHeaders(root, 2, 7);
return(headers);
}
public void UnhidingAddsHeaderToLinkedListInOriginalPosition()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeaders(root, EXPECTED_LENGTH);
ColumnHeader toTest = GetHeaderAt(root, EXPECTED_LENGTH);
toTest.Hide();
toTest.Unhide();
Assert.IsTrue(GetHeaderAt(root, EXPECTED_LENGTH).Equals(toTest));
}
private ColumnHeader[] GetHeadersWithLinkedNodes(HeaderRoot root)
{
ColumnHeader[] headers = GetHeaders(root, EXPECTED_LENGTH);
Node[] nodes = new Node[EXPECTED_LENGTH];
for (int i = 0; i < EXPECTED_LENGTH; i++)
{
nodes[i] = headers[i].CreateNode();
}
Node.LinkNodes(nodes);
return(headers);
}
public void CoveringAllHeadersWillLeaveRootLinkingToSelf()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeaders(root, EXPECTED_LENGTH);
for (int i = 0; i < headers.Length; i++)
{
headers[i].Cover();
}
Assert.IsTrue(root.right == root);
Assert.IsTrue(root.left == root);
}
public void ChooseColumnWillReturnMinColumn()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeaders(root, EXPECTED_LENGTH);
for (int i = 0; i < EXPECTED_LENGTH - 1; i++)
{
headers[i].CreateNode();
}
ColumnHeader chosen = root.ChooseColumnHeader();
Assert.AreEqual(headers[EXPECTED_LENGTH - 1], chosen);
}
public void NodeCanRemoveRow()
{
HeaderRoot root = GetRoot();
ColumnHeader headerSingle = new ColumnHeader(root);
ColumnHeader otherHeader = new ColumnHeader(root);
Node toRemove = headerSingle.CreateNode();
Node linked = otherHeader.CreateNode();
Node.LinkNodes(toRemove, linked);
toRemove.RemoveRow();
Assert.IsTrue(headerSingle.Size == 1);
Assert.IsTrue(otherHeader.Size == 0);
}
public void GetLinkedHeadersReturnsAccurateHeaders()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = new ColumnHeader[2];
Node[] nodes = new Node[2];
for (int i = 0; i < 2; i++)
{
headers[i] = root.CreateHeader();
nodes[i] = headers[i].CreateNode();
}
Node.LinkNodes(nodes);
Assert.IsTrue(root[0].down.GetLinkedHeaders().Count == 2);
}
public void CoverWillRemoveRowsFromAllHeaders()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeadersWithLinkedNodes(root);
headers[0].Cover();
int summedsizes = 0;
for (int i = 1; i < EXPECTED_LENGTH; i++)
{
summedsizes += headers[i].Size;
}
Assert.IsTrue(summedsizes == 0);
}
public void NodesCanBeAddedToHeaders()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeaders(root, EXPECTED_LENGTH);
for (int i = 0; i < headers.Length; i++)
{
headers[i].CreateNode();
}
for (int i = 0; i < headers.Length; i++)
{
Assert.IsTrue(headers[i].Size == 1);
}
}
public void NodeCanGetLinkedHeaders()
{
HeaderRoot root = GetRoot();
ColumnHeader headerSingle = new ColumnHeader(root);
Node single = headerSingle.CreateNode();
ColumnHeader headerSingleMultiRow = new ColumnHeader(root);
Node oneLinked = headerSingleMultiRow.CreateNode();
Node twoLinked1 = headerSingleMultiRow.CreateNode();
Node twoLinked2 = headerSingle.CreateNode();
Node.LinkNodes(twoLinked1, twoLinked2);
Assert.IsTrue(single.GetLinkedHeaders().Count == 1);
Assert.IsTrue(oneLinked.GetLinkedHeaders().Count == 1);
Assert.IsTrue(twoLinked1.GetLinkedHeaders().Count == 2);
}
public void SearchWillReturnACorrectNodeSolutionStackForComplicatedMatrix()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetKnownProblemHeaders(root);
Stack <Node> solutionActual = root.Search();
List <ColumnHeader> retrievedHeaders = new List <ColumnHeader>();
for (int i = 0; i < solutionActual.Count; i++)
{
retrievedHeaders.AddRange(solutionActual.ToArray()[i].GetLinkedHeaders());
}
Assert.IsTrue(retrievedHeaders.Count == root.Count);
Assert.IsTrue(solutionActual.Count == 3);
}
public void CoverWillSetOtherHeadersHeights()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeadersWithLinkedNodes(root);
headers[0].Cover();
int sum = 0;
ColumnHeader currheader = root.right;
while (currheader != root)
{
sum += currheader.Size;
currheader = currheader.right;
}
Assert.IsTrue(sum == 0);
}
public void CoverWillCorrectlySetOtherKnownHeadersHights()
{
HeaderRoot root = GetRoot();
ColumnHeader[] known = GetKnownProblemHeaders(root);
int[] expectedRemainingSize = GetKnownProblemHeaderCoverResults();
for (int i = 0; i < known.Length; i++)
{
known[i].Cover();
int sum = 0;
ColumnHeader temp = root.right;
while (temp != root)
{
sum += temp.Size;
temp = temp.right;
}
Assert.IsTrue(sum == expectedRemainingSize[i]);
known[i].Uncover();
}
}
public void UncoverRestoresRowsToOtherHeaders()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeaders(root, EXPECTED_LENGTH);
CreateAndLinkNodesToRandomHeaders(root, EXPECTED_LENGTH / 2);
CreateAndLinkNodesToRandomHeaders(root, EXPECTED_LENGTH / 2);
CreateAndLinkNodesToRandomHeaders(root, EXPECTED_LENGTH / 2);
CreateAndLinkNodesToRandomHeaders(root, EXPECTED_LENGTH / 2);
CreateAndLinkNodesToRandomHeaders(root, EXPECTED_LENGTH / 2);
CreateAndLinkNodesToRandomHeaders(root, EXPECTED_LENGTH / 2);
headers[0].Cover();
headers[0].Uncover();
int sum = 0;
for (int i = 0; i < EXPECTED_LENGTH; ++i)
{
sum += headers[i].Size;
}
Assert.IsTrue(sum == EXPECTED_LENGTH * 3);
}
/// <summary>
/// TODO: FIX THIS
/// </summary>
/// <param name="root"></param>
/// <param name="numToLink"></param>
private void CreateAndLinkNodesToRandomHeaders(HeaderRoot root, int numToLink)
{
int AvailableHeaderCount = root.Count;
List <int> workingIndex = new List <int>();
for (int i = 0; i < AvailableHeaderCount; i++)
{
workingIndex.Add(i);
}
Random rand = new Random();
Node[] toLink = new Node[numToLink];
for (int i = 0; i < numToLink; i++)
{
int chooseIndex = rand.Next(0, workingIndex.Count);
toLink[i] = GetHeaderAt(root, workingIndex[chooseIndex]).CreateNode();
workingIndex.RemoveAt(chooseIndex);
}
Node.LinkNodes(toLink);
}
public void UnhidingManyAddsHeaderToLinkedListInOriginalPosition()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeaders(root, EXPECTED_LENGTH);
Random random = new Random();
int numToHide = random.Next(0, EXPECTED_LENGTH);
int[] indexes = new int[numToHide];
List <ColumnHeader> hiddenHeaders = new List <ColumnHeader>();
List <int> numbers = new List <int>();
for (int i = 0; i < EXPECTED_LENGTH; i++)
{
numbers.Add(i);
}
for (int i = 0; i < numToHide; i++)
{
int numbersIndex = random.Next(0, numbers.Count);
indexes[i] = numbers[numbersIndex];
hiddenHeaders.Add(GetHeaderAt(root, numbers[numbersIndex]));
numbers.RemoveAt(numbersIndex);
}
foreach (ColumnHeader toHide in hiddenHeaders)
{
toHide.Hide();
}
foreach (ColumnHeader toHide in hiddenHeaders)
{
toHide.Unhide();
}
for (int i = 0; i < numToHide; i++)
{
Assert.IsTrue(hiddenHeaders[i].Equals(GetHeaderAt(root, indexes[i])));
}
}
public void CoverWillCorrectlySetOtherHeadersHeights()
{
HeaderRoot root = GetRoot();
ColumnHeader[] headers = GetHeadersWithLinkedNodes(root);
headers[0].Cover();
Random rand = new Random();
int numToLinkA = rand.Next(1, EXPECTED_LENGTH - 1);
int numToLinkB = rand.Next(1, EXPECTED_LENGTH - 1);
//Header 0 will always only have the one linked row;
CreateAndLinkNodesToRandomHeaders(root, numToLinkA);
CreateAndLinkNodesToRandomHeaders(root, numToLinkB);
int sum = 0;
ColumnHeader currHeader = root.right;
while (currHeader != root)
{
sum += currHeader.Size;
currHeader = currHeader.right;
}
Assert.IsTrue(sum == numToLinkA + numToLinkB);
}
