public void FetchCommandWorkingCorrectly()
{
int[] firstCopy = database.Fetch();
database.Add(9);
int[] secondCopy = database.Fetch();
Assert.That(firstCopy, Is.Not.EqualTo(secondCopy));
}
public void Database_Fetch_ReturnsArrayCopy()
{
//Act
var result = database.Fetch();
//Assert
CollectionAssert.AreEqual(result, fiveNumsArray);
}
public void AddAddsElementToDatabase()
{
int element = 7;
database.Add(element);
int[] databaseCopy = database.Fetch();
Assert.That(databaseCopy, Does.Contain(element));
}
public void AddElementToTheRightIndex()
{
int expectedElementIndex = db.Count;
db.Add(64);
int[] copyDB = db.Fetch();
Assert.That(copyDB[db.Count - 1], Is.EqualTo(64), "Couldn't Add element to right index in db.");
}
public void Add_AddElementToDatabase()
{
int element = 123;
database.Add(element);
int[] elements = database.Fetch();
Assert.IsTrue(elements.Contains(element));
}
public void Add_AddsElementToDatabase()
{
int element = 10;
database.Add(element);
var fetch = database.Fetch();
Assert.That(fetch.Contains(element));
}
public void When_UseAddMetodAndCapasityIsNotFull_Should_AddElement()
{
int element = 123;
database.Add(element);
int[] elements = database.Fetch();
Assert.IsTrue(elements.Contains(element));
}
public void Add_AddsElementToDatabase()
{
int element = 123456;
database.Add(element);
int[] copyDatabase = database.Fetch();
Assert.IsTrue(copyDatabase.Contains(element));
}
public void Add_AddsElementToDatabase()
{
int newElement = 123;
this.dataBase.Add(newElement);
int[] coppiedElements = dataBase.Fetch();
Assert.IsTrue(coppiedElements.Contains(newElement), "NewElements is not in the new fletched array!");
}
public void Remove_ElementFromDb()
{
var n = 3;
var lastElement = 2;
for (int i = 0; i < n; i++)
{
database.Add(i);
}
database.Remove();
var elements = database.Fetch();
Assert.IsFalse(elements.Contains(lastElement));
}
public void Add_Correctly()
{
//Arange
int[] expectedRes = { 0, 1, 2, 3, 4 };
//Act
database.Add(2);
database.Add(3);
database.Add(4);
int[] actualRes = database.Fetch();
//Assert
Assert.AreEqual(expectedRes, actualRes);
}
public void ConstructorShouldStoredIntegers()
{
var arr = Enumerable.Range(1, 16).ToArray();
Database.Database database = new Database.Database(arr);
CollectionAssert.AreEqual(arr,database.Fetch());
}
public void Test_If_Fetch_Works_Correctly()
{
var expected = new int[] { 1, 2 };
var actual = database.Fetch();
CollectionAssert.AreEqual(expected, actual);
}
public void AddOperationShouldAddAnElementAtTheNextFreeCell()
{
//// Arrange
//int[] data = new int[3] { 1, 2, 3 };
//Database.Database database = new Database.Database(data);
// Act
database.Add(15);
// Assert
int expectedElement = 15;
int actualElement = database.Fetch()[database.Count - 1];
Assert.AreEqual(expectedElement, actualElement);
}
public void Ctor_AddsElementsToDatabase()
{
int[] arr = new int[] { 1, 2, 3 };
database = new Database.Database(arr);
Assert.That(database.Count, Is.EqualTo(arr.Length));
Assert.That(database.Fetch(), Is.EqualTo(arr));
}
public void FetchShouldReturnCopyOfData(int[] expectedData)
{
database = new Database.Database(expectedData);
int[] actualData = database.Fetch();
CollectionAssert.AreEqual(expectedData, actualData);
}
public void FetchWorksProperly()
{
int[] nums = Enumerable.Range(1, 16).ToArray();
Database.Database database = new Database.Database(nums);
CollectionAssert.AreEqual(nums, database.Fetch());
}
public void Ctor_AddsElementsToDataBaseCorectyl()
{
int[] arr = new[] { 1, 2, 3, 4, };
Database.Database database = new Database.Database(arr);
Assert.That(database.Count, Is.EqualTo(arr.Length));
Assert.That(database.Fetch(), Is.EquivalentTo(arr)); // NB !!!! Is.EquivalentTo Дали 2 колекции съдържат едни и същи елементи!!!!!!!!!!!!!!!!!!!!!!!!!
}
public void FetchShouldReturnElementsInDatabaseAsArray()
{
int[] expectedElements = new int[] { 1, 2, 3 };
var database = new Database.Database(expectedElements);
int[] actualElements = database.Fetch();
Assert.AreEqual(expectedElements, actualElements);
}
public void Ctor_AddsToDatabase()
{
var massive = new[] { 1, 2, 3 };
database = new Database.Database(massive);
Assert.That(database.Count == massive.Length);
Assert.That(database.Fetch(), Is.EquivalentTo(massive));
}
public void When_ParamsAreProvidedByCtor_ShoudBeSetCorrectly()
{
int[] elements = new int[] { 1, 2, 3 };
database = new Database.Database(elements);
Assert.AreEqual(elements.Length, database.Count);
Assert.That(database.Fetch(), Is.EquivalentTo(elements));
}
public void When_CtorCorectly_Should_AddElements()
{
int[] arr = new int[] { 1, 2, 3, 4, 5, 6 };
database = new Database.Database(arr);
Assert.That(database.Count, Is.EqualTo(arr.Length));
Assert.That(database.Fetch(), Is.EquivalentTo(arr));
}
public void FetchMethodShouldWork()
{
int[] array = Enumerable.Range(1, 15).ToArray();
Database.Database database = new Database.Database(array);
int[] fetchArray = database.Fetch();
CollectionAssert.AreEqual(array, fetchArray);
}
public void RemoveMethodRemovesTheLastElementFromTheCollection()
{
int elementCount = 10;
for (int i = 0; i < elementCount - 1; i++)
{
data.Add(1);
}
int lastElement = 10;
data.Add(lastElement);
data.Remove();
var copy = data.Fetch();
Assert.IsFalse(copy.Contains(lastElement));
}
public void CanAdd()
{
var arr = Enumerable.Range(1, 14).ToArray();
Database.Database database = new Database.Database(arr);
database.Add(1);
int expected = 15;
int actual = database.Fetch().Length;
Assert.AreEqual(expected, actual);
}
public void ShouldRemoveNumbers()
{
var arr = Enumerable.Range(1, 14).ToArray();
Database.Database database = new Database.Database(arr);
database.Remove();
int expected = 13;
int actual = database.Fetch().Length;
Assert.AreEqual(expected, actual);
}
public void TheFetchMethodShouldReturnTheElementsAsArray()
{
//Arrange
Database.Database database = new Database.Database(this.addMethodArray);
//Act
int[] fetchedArray = database.Fetch();
//Assert
Assert.That(fetchedArray.Length, Is.EqualTo(database.Count));
}
public void AddWorksProperly()
{
int[] nums = Enumerable.Range(1, 10).ToArray();
Database.Database database = new Database.Database(nums);
database.Add(11);
int expectedCount = 11;
Assert.AreEqual(11, database.Fetch()[database.Count - 1]);
Assert.AreEqual(expectedCount, database.Count);
}
public void DatabaseShouldReturnSameArray()
{
int[] array = new int[5] {
1, 2, 3, 4, 5
};
Database.Database database = new Database.Database(array);
int[] returnedArray = database.Fetch();
int[] expectedArray = new int[5] {
1, 2, 3, 4, 5,
};
Assert.That(returnedArray, Is.EquivalentTo(expectedArray));
}
public void Remove_Operation_Should_Return_Element_As_Array()
{
//Arrange
int[] numbers = Enumerable.Range(1, 5).ToArray();
Database.Database database = new Database.Database(numbers);
//Act
int[] returnedArray = database.Fetch();
//Assert
int[] expectedCountResult = { 1, 2, 3, 4, 5 };
Assert.AreEqual(returnedArray, expectedCountResult);
}
