public void Test()
{
//Arrange
int[] nonExistingElements = new int[] { 2, -14, 85 };
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
//Act & Assert
foreach (var el in elements)
{
bool exists = bst.Exists(el);
Assert.True(exists);
}
foreach (int nonExistingKey in nonExistingElements)
{
bool exists = bst.Exists(nonExistingKey);
Assert.False(exists);
}
}
public void CountUpdated()
{
//Arrange
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
//Act & Assert
for (int i = 0; i < elements.Length; i++)
{
var currentEl = elements[i];
bst.Insert(currentEl);
Assert.Equal(i + 1, bst.Count);
}
}
public void NoKey_ExceptionThrown()
{
//Arrange
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
//Act
Action act = () => bst.Get(85);
//Assert
Assert.Throws <InvalidOperationException>(act);
}
public void HappyPath_ElementReturned()
{
//Arrange
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
//Assert
foreach (int el in elements)
{
int foundEl = bst.Get(el);
Assert.Equal(el, foundEl);
}
}
public void ElementExists_ElementReturned()
{
//Arrange
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
int referentValue = 36;
//Act
int ceilingValue = bst.Ceiling(referentValue);
//Assert
Assert.Equal(referentValue, ceilingValue);
}
public void ArgumentsOutOfRange_AllReturned()
{
//Arrange
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
//Act
IEnumerable <int> values = bst.Values(-1000, 1000);
//Assert
int[] expectedValues = elements.OrderBy(x => x).ToArray();
int[] valuesArray = values.ToArray();
Assert.True(expectedValues.SequenceEqual(valuesArray));
}
public void MaxReturned()
{
//Arrange
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
//Act
int maxEl = bst.Max();
//Assert
int actualMax = elements.Max();
Assert.Equal(actualMax, maxEl);
}
public void Deleted()
{
//Arrange
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
//Act & Assert
foreach (var element in elements)
{
bst.Delete(element);
bool exists = bst.Exists(element);
Assert.False(exists);
}
}
public void ElementDoesntExist_CeilingReturned()
{
//Arrange
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
int referentValue = 38;
//Act
int ceilingValue = bst.Ceiling(referentValue);
//Assert
int actualCeiling = elements.Where(x => x >= referentValue).Min();
Assert.Equal(actualCeiling, ceilingValue);
}
public void NoDuplicates()
{
//Arrange
int duplicateValue = 24;
int[] elements = new int[] { 1, -5, duplicateValue, 561, -300, 15, 36, duplicateValue, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
//Act
foreach (int el in elements)
{
bst.Insert(el);
}
//Assert
var allValues = bst.Values();
var matchingValues = allValues.Where(x => x == duplicateValue);
Assert.Single(matchingValues);
}
public void CountUpdated()
{
//Arrange
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
//Act & Assert
for (int i = 0; i < elements.Length; i++)
{
var element = elements[i];
bst.Delete(element);
int expectedLength = elements.Length - i - 1;
Assert.Equal(expectedLength, bst.Count);
}
}
public void CorrectRankReturned()
{
//Arrange
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
//Act & Assert
var sortedElements = elements.OrderBy(x => x).ToArray();
for (int i = 0; i < sortedElements.Length; i++)
{
var currentElement = sortedElements[i];
int rank = bst.Rank(currentElement);
Assert.Equal(i, rank);
}
}
public void ArgumentsInRange_RangeReturned()
{
//Arrange
int lo = 1;
int hi = 100;
int[] elements = new int[] { 1, -5, 24, 561, -300, 15, 36, 82, 4, 50 };
BinarySearchTreeSet <int> bst = new BinarySearchTreeSet <int>();
foreach (int el in elements)
{
bst.Insert(el);
}
//Act
IEnumerable <int> values = bst.Values(lo, hi);
//Assert
int[] expectedValues = elements.Where(x => x >= lo && x <= hi).OrderBy(x => x).ToArray();
int[] valuesArray = values.ToArray();
Assert.True(expectedValues.SequenceEqual(valuesArray));
}