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