public void ShoudIncreaseCount_WnenAddingElement()
{
int expextedCount = database.Count + 1;
database.Add(9);
Assert.AreEqual(database.Count, expextedCount);
}
public void AddElementToAvailableSlot()
{
int expectedCount = db.Count + 1;
db.Add(1);
Assert.That(db.Count, Is.EqualTo(expectedCount), "Couldn't Add element to db.");
}
public void CheckArrayThatIsItEqualTo16()
{
for (int i = 0; i < 16; i++)
{
database.Add(i);
}
Assert.That(database.Count, Is.EqualTo(16));
}
public void Add_ThrowsException_WhenCapacityIsExceeded()
{
for (int i = 0; i < 16; i++)
{
database.Add(i);
}
Assert.Throws <InvalidOperationException>(() => database.Add(17));
}
public void AddCommand_ShouldThrowException_WhenCountIs16()
{
database = new Database.Database();
for (int i = 0; i < 16; i++)
{
database.Add(i);
}
Assert.Throws <InvalidOperationException>(() => database.Add(17));
}
public void AddShouldIncreaseCount()
{
database.Add(1);
int expectedCount = 3;
int actualCount = database.Count;
Assert.AreEqual(expectedCount, actualCount);
}
public void When_UseAddMetodAndCapasityIsFull_ShouldThow()
{
for (int i = 0; i < 16; i++)
{
database.Add(i);
}
Assert.Throws <InvalidOperationException>(() => database.Add(17));
}
public void When_CapacityReached_ShouldThrowException()
{
for (int i = 0; i < 16; i++)
{
data.Add(i);
}
Assert.Throws <InvalidOperationException>(() => data.Add(18));
//Assert.That(count, Is.EqualTo(16), "Array's capacity must be exactly 16 integers!");
}
public void DatabaseShouldThrowInvalidOperationExceptionWhenCountIsBiggerThan16()
{
int[] array = Enumerable.Range(1, 15).ToArray();
Database.Database database = new Database.Database(array);
database.Add(1);
Assert.That(database.Count, Is.EqualTo(16));
Assert.Throws <InvalidOperationException>(() => database.Add(1));
}
public void TheAddMethodShouldAddElementsAtTheNextFreeCell()
{
//Arrange
Database.Database database = new Database.Database(this.addMethodArray);
//Act
database.Add(16);
//Assert
Assert.That(database.Count, Is.EqualTo(16));
Assert.That(() =>
{
database.Add(17);
}, Throws.InvalidOperationException.With.Message.EqualTo("Array's capacity must be exactly 16 integers!"));
}
public Database <T> GetDatabase <T>(Guid universeGuid, int planetId, bool fixedValueSize) where T : ITag, new()
{
(Type, Guid universeGuid, int planetId)key = (typeof(T), universeGuid, planetId);
using (planetSemaphore.Wait())
{
if (planetDatabaseRegister.TryGetValue(key, out Database.Database database))
{
return(database as Database <T>);
}
else
{
Database <T> tmpDatabase = CreateDatabase <T>(Path.Combine(rootPath, universeGuid.ToString(), planetId.ToString()), fixedValueSize);
try
{
tmpDatabase.Open();
}
catch (Exception ex)
{
tmpDatabase.Dispose();
logger.Error($"Can not Open Database for [{universeGuid}]{planetId}, {typeof(T).Name}", ex);
throw ex;
}
planetDatabaseRegister.Add(key, tmpDatabase);
return(tmpDatabase);
}
}
}
public void DatabaseArrayShouldAddElement()
{
int[] array = new int[10];
Database.Database database = new Database.Database(array);
database.Add(2);
Assert.That(database.Count == 11);
}
public void AddShouldThrowsExceptionWhenDatabaseCountIsBiggerThenSixteen()
{
var database = new Database.Database(Enumerable.Range(1, 16).ToArray());
var exception = Assert.Throws <InvalidOperationException>(() => database.Add(17));
Assert.AreEqual("Array's capacity must be exactly 16 integers!", exception.Message);
}
public void AddShouldSuccessfullyInsertElement()
{
var database = new Database.Database();
database.Add(5);
Assert.AreEqual(1, database.Count);
}
public void AddOperationShouldIncreasesCount()
{
//// Arrange
//int[] data = new int[3] { 1, 2, 3 };
//Database.Database database = new Database.Database(data);
// Act
database.Add(15);
// Assert
int expectedCount = 4;
int actualCount = database.Count;
Assert.AreEqual(expectedCount, actualCount);
}
public void Test_Add_Element()
{
int[] nums = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
this.database = new Database(nums);
database.Add(11);
Assert.AreEqual(11, this.database.Count);
}
public void FetchShouldReturnAllValidElements()
{
// Arange
int[] expected = new int[] { 1, 2 };
var database = new Database.Database(1, 2, 3);
// Act
database.Add(4);
database.Add(5);
database.Remove();
database.Remove();
database.Remove();
int[] fetched = database.Fetch();
// Assert
Assert.AreEqual(expected, fetched);
}
public void AddThrowsException()
{
int[] nums = Enumerable.Range(1, 16).ToArray();
Database.Database database = new Database.Database(nums);
Assert.Throws <InvalidOperationException>(() => database.Add(17));
}
public void Add_IncrementCountWhenAddIsValid()
{
var n = 5;
for (int i = 0; i < n; i++)
{
database.Add(i);
}
Assert.That(database.Count, Is.EqualTo(n));
}
public void AddMoreThan16Numbers_ThrowsException()
{
//Arange
int[] numbers = new int[16];
database = new Database.Database(numbers);
//Assert
Assert.Throws<InvalidOperationException>(() => database.Add(3), "Oh well, whatever, nevermind");
}
public void Database_Add_MethodAdds(int number)
{
//Arrange
//Act
database.Add(number);
//Assert
Assert.AreEqual(6, database.Count);
}
public void Add_Operation_Should_Throw_Invalid_Operation_Exception_If_Add_More_Than_16_Element()
{
//Arrange
int[] numbers = Enumerable.Range(1, 16).ToArray();
Database.Database database = new Database.Database(numbers);
//Act - Assert
Assert.Throws <InvalidOperationException>(() => database.Add(5));
}
public void AddOperationShouldThrowExceptionWhenTryToExceedMaxCapacity()
{
// Arrange
int[] data = new int[DatabaseCapacity];
Database.Database database = new Database.Database(data);
// Assert
Assert.That(
() => database.Add(15), // Act
Throws.InvalidOperationException.With.Message.EqualTo("Array's capacity must be exactly 16 integers!"));
}
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 AddShouldAddElementAtNextFreeCell()
{
var database = new Database.Database(1, 2, 3);
int initialCount = database.Count;
int integerToAdd = 4;
database.Add(integerToAdd);
int actual = database.Count;
Assert.That(actual, Is.EqualTo(initialCount + 1));
}
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 CannotAddAnElementAtTheNextFreeCell()
{
int[] dataArr = new int[16];
for (int i = 0; i < 15; i++)
{
dataArr[i] = 0;
}
dataBase = new Database.Database(dataArr);
Assert.That(() => dataBase.Add(0), Throws.InvalidOperationException);
}
public void AddMethodThrowExceptionWhenCapacityExceeded()
{
for (int i = 0; i < 16; i++)
{
data.Add(i);
}
Assert.That(() => data.Add(17),
Throws.InvalidOperationException.With.Message.EqualTo("Array's capacity must be exactly 16 integers!"));
}
public void Add_ThrowsException_WhenCapacityIsIxceeded()
{
for (int i = 0; i < dataBaseCapacity; i++)
{
dataBase.Add(i);
}
Assert.That(() =>
{
dataBase.Add(17);
}, Throws.InvalidOperationException.With.Message.EqualTo("Array's capacity must be exactly 16 integers!"));
}
public void Database_Add_MethodThrowsExceptionWhenLimitReached(int number)
{
//Arrange
var sixteenNumsArray = new int[16] {
12, 2, 3, 34, 5, 6, 7, 8, 99, 10, 11, 12, 13, 14, 15, 16
};
var database = new Database.Database(sixteenNumsArray);
//Act
//Assert
Assert.That(() => database.Add(1), Throws.InvalidOperationException
.With.Message.EqualTo("Array's capacity must be exactly 16 integers!"));
Assert.That(database.Count.Equals(16));
}
