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)); }