public void Constructor_ShouldWorkCorrectly()
{
Database db = new Database(1, 2, 3, 4, 5);
for (int expectedResult = 5; expectedResult > 0; expectedResult--)
{
int actualResult = db.Remove();
Assert.That(actualResult, Is.EqualTo(expectedResult));
}
}
public void RemovingElementOfLastIndex()
{
int[] array = new int[4];
Database database = new Database(array);
database.Remove();
int expected = 3;
int current = database.Count;
Assert.AreEqual(expected, current);
}
public void Remove_Check_RemovingSequence()
{
Database database = new Database(1, 2, 3);
database.Remove();
int[] actual = database.Fetch();
int[] expected = { 1, 2 };
Assert.That(actual, Is.EqualTo(expected));
}
public void RemoveMethod_ShouldRemoveOnlyOneElement()
{
var database = new Database(1, 2, 3);
database.Remove();
int expectedDatabaseElements = 2;
int actualDatabaseElements = database.Fetch().Length;
Assert.AreEqual(expectedDatabaseElements, actualDatabaseElements);
}
public void shouldRemoveCorrectlyAndDecreaseCount()
{
int[] array = { 1, 2, 3 };
Database database = new Database(array);
database.Remove();
int expectedCount = 2;
int actualCount = database.Count;
Assert.AreEqual(expectedCount, actualCount);
}
public void shouldRemoveCorrectlyLastElement()
{
int[] array = { 1, 2, 3 };
Database database = new Database(array);
database.Remove();
int expectedCount = 2;
int actualCount = database.Fetch()[1];
Assert.AreEqual(expectedCount, actualCount);
}
public void ShouldRemoveCOrrextrlyLastElement()
{
int[] arr = new int[3];
Database dataNew = new Database(arr);
dataNew.Remove();
int expectedCount = 0;
int actualCount = dataNew.Fetch()[dataNew.Count - 1];
Assert.AreEqual(expectedCount, actualCount);
}
public void Remove_CheckCount_RemovingNumbers()
{
int[] arr = new int[16];
Database database = new Database(arr);
database.Remove();
int actual = database.Count;
int expected = 15;
Assert.That(actual, Is.EqualTo(expected));
}
public void ShouldRemoveCorrectlyLastElement()
{
var array = new int[] { 1, 2, 3 };
var database = new Database(array);
database.Remove();
int expectedValue = 2;
int actualValue = database.Fetch()[database.Count - 1];
Assert.AreEqual(expectedValue, actualValue);
}
public void MethodShouldRemoveLastElementOfTheArray()
{
int[] array = { 1, 2, 3 };
Database database = new Database(array);
database.Remove();
int expectedValue = 2;
int actualValue = database.Fetch()[database.Count - 1];
Assert.AreEqual(expectedValue, actualValue);
}
public void RemovingAnElementAtTheLastIndex()
{
int[] data = new int[]
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
};
Database database = new Database(data);
database.Remove();
Assert.That(database.Count is 9);
}
public void RemoveShouldRemoveTheLastPerson()
{
var person = new People[] { firstPerson, secondPerson };
var database = new Database(person);
database.Remove();
var expectedResult = new People[] { firstPerson };
var actualResult = database.Fetch();
Assert.That(actualResult, Is.EqualTo(expectedResult));
}
public void TestingFetchMethod()
{
int[] array = new int[] { 1, 2, 3, 4, 5 };
database = new Database(array);
int[] arrayBeforeRemove = database.Fetch();
database.Remove();
int[] arrayAfterRemove = database.Fetch();
Assert.That(arrayBeforeRemove, Is.Not.EquivalentTo(arrayAfterRemove));
}
public void ShouldRemoveLastElement()
{
int[] arrayr = new int[10];
data = new Database(arrayr);
data.Remove();
int[] newArray = data.Fetch();
int expectedValueAfterRemoval = 0;
int removedElementValue = newArray[newArray.Length + 1];
Assert.AreEqual(expectedValueAfterRemoval, removedElementValue);
}
public void WhenCollectionIsNotEmptyAndUsingRemove()
{
int[] array = new int[] { 1, 2, 3, 4, 5 };
database = new Database(array);
int[] arrayBeforeRemove = database.Fetch();
database.Remove();
int[] arrayAfterRemove = database.Fetch();
Assert.That(arrayAfterRemove.Length == database.Count);
}
public void ShouldDecreaseCounterWhenRemovingElement()
{
int[] arrayr = new int[10];
data = new Database(arrayr);
data.Remove();
int[] newArray = data.Fetch();
int expectedNewCount = 9;
int newCount = newArray.Length;
Assert.AreEqual(expectedNewCount, newCount);
}
public void RemoveOperationShouldSupportOnlyRemovingAnElementAtTheLast()
{
//Arrange
int[] numbers = Enumerable.Range(1, 16).ToArray();
Database database = new Database(numbers);
//Act
database.Remove();
int expectedresult = 15;
int actualResult = database.Count;
//Assert
Assert.AreEqual(expectedresult, actualResult);
}
public void RemoveSingleElement()
{
//Arrange
Database db = new Database(new List <int>()
{
1, 2, 3, 4
});
//Act
db.Remove();
//Assert
CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, db.Elements);
}
public void RemoveOperationShouldRemoveElementAtTheLastIndex()
{
//Arange
Database data = new Database(Enumerable.Range(1, 10).ToArray());
//Act
data.Remove();
var resultArray = data.Fetch();
//Assert
var expectedResult = 9;
var actualResult = resultArray[resultArray.Length - 1];
Assert.AreEqual(expectedResult, actualResult);
}
public void AddRemove_ShouldWorkCorrectly(int amount)
{
Database db = new Database();
for (int i = 0; i < amount; i++)
{
db.Add(i);
}
for (int expectedResult = amount - 1; expectedResult >= 0; expectedResult--)
{
int actualResult = db.Remove();
Assert.That(actualResult, Is.EqualTo(expectedResult));
}
}
public void RemoveOperationShouldRemoveTheLastElement()
{
int[] numbers = Enumerable.Range(1, 16).ToArray();
Database database = new Database(numbers);
database.Remove();
int expected = 15;
int actual = database.Fetch()[14];
int expectedCount = 15;
int actualCount = database.Count;
Assert.AreEqual(expected, actual);
Assert.AreEqual(expectedCount, actualCount);
}
// [Test]
public void RemoveMethodShouldTrownExeption()
{
var database = new Database(new int[] { 1, 2, 3, 5, 5 });
database.Remove();
database.Remove();
database.Remove();
database.Remove();
database.Remove();
Assert.That(() => database.Remove(), Throws.InvalidOperationException);
}
public void RemoveShouldDecreaseCountWhenSuccessful()
{
int[] numbers = Enumerable.Range(1, 10).ToArray();
Database database = new Database(numbers);
database.Remove();
int expectedValue = 9;
int actualValue = database.Fetch()[8];
int expectedCount = 9;
int actualCount = database.Count;
Assert.AreEqual(expectedValue, actualValue);
Assert.AreEqual(expectedCount, actualCount);
}
public void ValidIfRemovestheLastElement(string message, params int[] data)
{
var testDatabase = new Database(data);
testDatabase.Remove();
int[] copy = testDatabase.Fetch();
for (int i = 1; i < 16; i++)
{
if (copy[i - 1] != i)
{
Assert.Fail(message);
}
}
Assert.Pass();
}
public void Remove_Operation_Should_Support_Only_Remove_An_Element_At_The_Last_Index()
{
// Arrange
int[] testArray = { 1, 2 };
Database database = new Database(testArray);
// Act
database.Remove();
int expectedResult = 1;
int actualResult = database.Fetch()[0];
int actualCount = 1;
int expectedCount = database.Count;
// Assert
Assert.AreEqual(expectedResult, actualResult);
Assert.AreEqual(expectedCount, actualCount);
}
public void FechTest()
{
db.Remove();
db.Remove();
db.Remove();
db.Remove();
db.Remove();
db.Remove();
db.Remove();
db.Add(10);
var actual = db.Fetch();
var expected = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Assert.That(actual, Is.EqualTo(expected));
}
public void RemoveOperationRemovingLastIndex()
{
//Arange
int[] numbers = Enumerable.Range(1, 16).ToArray();
Database database = new Database(numbers);
database.Remove();
//Act
var expectedResult = 15;
var acctualResult = database.Count;
//Assert
Assert.AreEqual(expectedResult, acctualResult);
}
public void RemoveOperationShouldSupportOnlyRemovingElementAtLastIndex()
{
//Arrange
int[] numbers = Enumerable.Range(1, 10).ToArray();
Database database = new Database(numbers);
//Act
database.Remove();
//Assert
var expectedResult = 9;
var actualResult = database.Fetch()[8];
var expectedCount = 9;
var actualCount = database.Count;
Assert.AreEqual(expectedResult, actualResult);
Assert.AreEqual(expectedCount, actualCount);
}
public void DBTest_Add_ShouldRemoveElement(int[] initValues)
{
// Arrange
Database localDB = new Database(initValues);
// Act
var internalArrayValue = (int?[])typeof(Database)
.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
.Where(x => x.Name == "internalArray")
.FirstOrDefault()
.GetValue(localDB);
var internalArrayLength = internalArrayValue
.Where(x => x != null)
.Count();
localDB.Remove();
var elementsAfterOperation = localDB.Fetch();
// Assert
Assert.That(internalArrayLength - 1, Is.EqualTo(elementsAfterOperation.Length), "Remove operation was not successful!");
}
public void TestRemoveMethodValid(int[] vaulues)
{
Database db = new Database();
FieldInfo fieldInfo = typeof(Database).GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
.First(fi => fi.FieldType == typeof(int[]));
fieldInfo.SetValue(db, vaulues);
FieldInfo currentIndexInfo = typeof(Database).GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
.First(fi => fi.FieldType == typeof(int));
currentIndexInfo.SetValue(db, vaulues.Length);
db.Remove();
int[] actualValues = (int[])fieldInfo.GetValue(db);
int[] buffer = new int[actualValues.Length - vaulues.Length - 1];
vaulues = vaulues.Take(vaulues.Length - 1).Concat(buffer).ToArray();
Assert.That(actualValues, Is.EquivalentTo(vaulues));
}
