public void Test13()
{
Computer computer = new Computer("name", "model", 1.23m);
ComputerManager computerManager = new ComputerManager();
computerManager.AddComputer(computer);
Assert.AreEqual(computer, computerManager.Computers.First(x => x.Manufacturer == "name" && x.Model == "model"));
}
public void Test14()
{
Computer computer = new Computer("name", "model", 1.23m);
ComputerManager computerManager = new ComputerManager();
computerManager.AddComputer(computer);
Assert.AreEqual(computer, computerManager.RemoveComputer("name", "model"));
}
public void RemoveComputer_ShouldThrow_WhenComputerIsInvalid(string manufacturer, string model, decimal price)
{
// arrange
var computerManager = new ComputerManager();
var computer = new Computer(manufacturer, model, price);
// act, assert
computerManager.AddComputer(computer);
Assert.Throws <ArgumentException>(() => computerManager.RemoveComputer("another", "nonexistent"));
}
public void ComputerManager_ShouldHaveZeroCount_WhenInitialized()
{
// arrange
var computerManager = new ComputerManager();
// act, assert
Assert.Zero(computerManager.Count);
Assert.IsEmpty(computerManager.Computers);
Assert.NotNull(computerManager);
}
public void GetComputersByManufacturer_ShouldThrow_WhenComputerDataIsInvalid(string manufacturer)
{
// arrange
var computerManager = new ComputerManager();
var computer = new Computer(manufacturer, "ads", 123.40m);
// act, assert
computerManager.AddComputer(computer);
Assert.Throws <ArgumentNullException>(() => computerManager.GetComputersByManufacturer(manufacturer));
}
public void GetCompShlothrExcp()
{
ComputerManager manager = new ComputerManager();
Assert.Throws <ArgumentNullException>(() => manager.GetComputer(null, "DJONI"));
Assert.Throws <ArgumentNullException>(() => manager.GetComputer("DJONI", null));
Assert.Throws <ArgumentException>(() => manager.GetComputer("ZaZA", "bOBI"));
}
public void ComputerManagerGetMethodEception()
{
ComputerManager compMan = new ComputerManager();
Computer comp = new Computer("DC", "A", (decimal)5.5);
compMan.AddComputer(comp);
Assert.That(() => compMan.RemoveComputer("DC", "B"), Throws.ArgumentException.With.Message.EqualTo("There is no computer with this manufacturer and model."));
}
public void AddMethodShouldThrowExceptionIfNullOrDuplivateDataIsPassed()
{
var computerManager = new ComputerManager();
var computer = new Computer("Test", "Test", 10);
Assert.Throws <ArgumentNullException>(() => computerManager.AddComputer(null));
computerManager.AddComputer(computer);
Assert.Throws <ArgumentException>(() => computerManager.AddComputer(computer));
}
public void GetComputer_ShouldThrow_WhenComputerIsNotPresent(string manufacturer, string model, decimal price)
{
// arrange
var computerManager = new ComputerManager();
var computer = new Computer(manufacturer, model, price);
// act, assert
computerManager.AddComputer(computer);
Assert.Throws <ArgumentException>(() => computerManager.GetComputer("x", "nonexistent"));
}
public void MethodShouldThrowExceptionWhenComputerIsNull()
{
Computer computer = null;
ComputerManager manager = new ComputerManager();
Assert.Throws <ArgumentNullException>(() =>
{
manager.AddComputer(computer);
});
}
public void GetComputersByManufacturerShouldReturnEmptyCollectionWhenNoMatchesFound()
{
ComputerManager computerManager = new ComputerManager();
computerManager.AddComputer(this.computer);
var collection = computerManager.GetComputersByManufacturer("Asus").ToList();
CollectionAssert.IsEmpty(collection);
}
public void IsRemoveComputerReturnCorrectComp()
{
Computer comp = new Computer("Apple", "MacBook", 1500.50M);
ComputerManager manager = new ComputerManager();
manager.AddComputer(comp);
Assert.AreEqual(comp, manager.RemoveComputer("Apple", "MacBook"));
}
public void LoadComputersInfo()
{
var indexDirectory = Path.GetFullPath(WebConfigurationManager.AppSettings ["IndexDirectory"]);
var computersDirectory = Path.GetFullPath(WebConfigurationManager.AppSettings ["ComputersDirectory"]);
var computersManager = new ComputerManager(indexDirectory, computersDirectory);
ComputersInfo = computersManager.GetComputersInfo();
}
public void AddComputerMethod_Should()
{
Computer comp = new Computer("Apple", "MacBook", 1500.50M);
ComputerManager manager = new ComputerManager();
manager.AddComputer(comp);
Assert.AreEqual(comp, manager.Computers.First(x => x.Manufacturer == "Apple" && x.Model == "MacBook"));
}
public void IsAddComputerChangeCount()
{
Computer comp = new Computer("Apple", "MacBook", 1500.50M);
ComputerManager manager = new ComputerManager();
manager.AddComputer(comp);
Assert.AreEqual(1, manager.Count);
}
public void GetComputerModelCanNotBeNull()
{
Computer comp = new Computer("Apple", "MacBook", 1550.50M);
ComputerManager manager = new ComputerManager();
manager.AddComputer(comp);
Assert.Throws <ArgumentNullException>(() => manager.GetComputer("Apple", null));
}
public void IsAddedCompIsExist_Should()
{
Computer comp = new Computer("Apple", "MacBook", 1500.50M);
ComputerManager manager = new ComputerManager();
manager.AddComputer(comp);
Assert.Throws <ArgumentException>(() => manager.AddComputer(comp));
}
public void IsGetComputerMethodReturnsCorrectComp()
{
Computer comp = new Computer("Apple", "MacBook", 1550.50M);
ComputerManager manager = new ComputerManager();
manager.AddComputer(comp);
Assert.AreEqual(comp, manager.GetComputer("Apple", "MacBook"));
}
public void ComputerManagerGetMethodReturn()
{
ComputerManager compMan = new ComputerManager();
Computer comp = new Computer("DC", "A", (decimal)5.5);
compMan.AddComputer(comp);
Computer compRemoved = compMan.GetComputer("DC", "A");
Assert.That(compRemoved, Is.EqualTo(compRemoved));
}
public void MethodAddComputerShouldThrowExceptionIfComputerIsNull()
{
//Arrange
ComputerManager computerManager = new ComputerManager();
Computer computer = null;
//Act - Assert
Assert.Throws <ArgumentNullException>(()
=> computerManager.AddComputer(computer));
}
public void RemoveShouldThrowExceptionWhenManufacturerNull()
{
ComputerManager computerManager = new ComputerManager();
computerManager.AddComputer(this.defaultComputer);
Assert.Throws <ArgumentNullException>(() =>
{
var computer = computerManager.RemoveComputer(null, "Model");
});
}
public void RemoveShouldThrowExceptionWhenNullModel()
{
ComputerManager computerManager = new ComputerManager();
computerManager.AddComputer(this.computer);
Assert.Throws <ArgumentNullException>(() =>
{
var computer = computerManager.RemoveComputer(this.computer.Manufacturer, null);
});
}
public void GetComputersByManufacturerShouldThrowExceptionWhenManufacturerIsNull()
{
ComputerManager computerManager = new ComputerManager();
computerManager.AddComputer(this.defaultComputer);
Assert.Throws <ArgumentNullException>(() =>
{
var collection = computerManager.GetComputersByManufacturer(null);
});
}
public void GetComputerShouldThrowExcInavlidData()
{
ComputerManager cm = new ComputerManager();
Computer computer = new Computer("Lenovo", "A50", 1500.50m);
Computer computer2 = new Computer("Lenovooo", "A50000", 15000.50m);
cm.AddComputer(computer);
cm.AddComputer(computer2);
Assert.Throws <ArgumentException>(() => cm.GetComputer("Lenovo", "A"));
}
public void GetComputerByManufacturerShouldThrowExcNull()
{
ComputerManager cm = new ComputerManager();
Computer computer = new Computer("Lenovo", "A50", 1500.50m);
Computer computer2 = new Computer("Lenovooo", "A50000", 15000.50m);
cm.AddComputer(computer);
cm.AddComputer(computer2);
Assert.Throws <ArgumentNullException>(() => cm.GetComputersByManufacturer(null));
}
public void Add_Method_Should_Throw_An_Exception_If_We_Try_To_Add_Existing_Computer()
{
var computerManager = new ComputerManager();
var computer = new Computer("Abcd", "dcba", 20000);
computerManager.AddComputer(computer);
Assert.Throws <ArgumentException>(
() => computerManager.AddComputer(new Computer("Abcd", "dcba", 19)),
"This computer is not existing.");
}
public void GetComputersByManufacturerCanNotBeNull()
{
Computer comp = new Computer("Apple", "MacBook", 1550.50M);
ComputerManager manager = new ComputerManager();
manager.AddComputer(comp);
string man = null;
Assert.Throws <ArgumentNullException>(() => manager.GetComputersByManufacturer(man));
}
public void AddComputer_ShouldThrowException_WhenInvalidArgumentsAreGiven()
{
//Arrange
ComputerManager computerManager = new ComputerManager();
Computer testComputer = new Computer("Lenovo", "S 5000", 1000);
// Act - Assert
Assert.Throws <ArgumentNullException>(() => computerManager.AddComputer(null));
computerManager.AddComputer(testComputer);
Assert.Throws <ArgumentException>(() => computerManager.AddComputer(testComputer));
}
public void RemoveComputerShouldThrowException()
{
var computerManager = new ComputerManager();
var computer = new Computer("Test", "Test", 10);
computerManager.AddComputer(computer);
Assert.Throws <ArgumentNullException>(() => computerManager.RemoveComputer(null, "Test"));
Assert.Throws <ArgumentNullException>(() => computerManager.RemoveComputer("Test", null));
Assert.Throws <ArgumentException>(() => computerManager.RemoveComputer("wow", "wow"));
}
public void GetComputerShouldWorkAsExpected()
{
var computerManager = new ComputerManager();
var computer = new Computer("Test", "Test", 10);
computerManager.AddComputer(computer);
var computerFromComputerManager = computerManager.GetComputer("Test", "Test");
Assert.AreEqual(computer, computerFromComputerManager);
}
/// <summary>
/// Actives the rotate.
/// </summary>
/// <param name='pComputer'>
/// P computer.
/// </param>
public void ActiveRotate(ComputerManager pComputer)
{
this._activeRotate = true;
this._listComputer.Add(pComputer);
}
public void RemoveTerminal()
{
this._terminalCreation = null;
}
public void SetComputer(ComputerManager pTerminal)
{
this._terminalCreation = pTerminal;
}
/// <summary>
/// Sets the computer spawn.
/// </summary>
/// <param name='pComputer'>
/// P computer.
/// </param>
public void SetComputerSpawn(ComputerManager pComputer)
{
pComputer.OnSpawnBehaviour();
this._computerSpawnList.Add(pComputer);
this.SetNewState(FiniteStateMachineType.PATROL);
}
