public void TestWhenCapacityIsEqualToInputModule()
{
var capacity = 1;
ModuleContainer moduleContainer = new ModuleContainer(capacity);
var modele1 = new CryogenRod(1, 100);
moduleContainer.AddEnergyModule(modele1);
var module2 = new HeatProcessor(2, 200);
moduleContainer.AddAbsorbingModule(module2);
var actualEnergy = moduleContainer.TotalEnergyOutput;
var expectedEnergy = 0;
var actualAbsorbsion = moduleContainer.TotalHeatAbsorbing;
var expectedAbsorbtion = 200;
var actualModuleIntut = moduleContainer.ModulesByInput.Count;
var expectedModuleInput = 1;
Assert.That(actualEnergy, Is.EqualTo(expectedEnergy));
Assert.That(actualAbsorbsion, Is.EqualTo(expectedAbsorbtion));
Assert.That(actualModuleIntut, Is.EqualTo(expectedModuleInput));
}
public string ModuleCommand(IList <string> arguments)
{
int reactorId = int.Parse(arguments[0]);
string moduleType = arguments[1];
int additionalParameter = int.Parse(arguments[2]);
switch (moduleType)
{
case "CryogenRod":
IEnergyModule cryogenRod = new CryogenRod(this.currentId, additionalParameter);
this.reactors[reactorId].AddEnergyModule(cryogenRod);
this.identifiableObjects.Add(cryogenRod.Id, cryogenRod);
this.modules.Add(cryogenRod.Id, cryogenRod);
break;
case "HeatProcessor":
IAbsorbingModule heatProcessor = new HeatProcessor(this.currentId, additionalParameter);
this.reactors[reactorId].AddAbsorbingModule(heatProcessor);
this.identifiableObjects.Add(heatProcessor.Id, heatProcessor);
this.modules.Add(heatProcessor.Id, heatProcessor);
break;
case "CooldownSystem":
IAbsorbingModule coolDownSystem = new CooldownSystem(this.currentId, additionalParameter);
this.reactors[reactorId].AddAbsorbingModule(coolDownSystem);
this.identifiableObjects.Add(coolDownSystem.Id, coolDownSystem);
this.modules.Add(coolDownSystem.Id, coolDownSystem);
break;
}
string result = string.Format(Constants.ModuleCreateMessage, moduleType, this.currentId++, reactorId);
return(result);
}
public void CheckAddAfterReachingCappacity()
{
int cappacityOfContainer = 2;
int moduleId = 1;
int moduleAdditionalParameter = 10;
IContainer container = new ModuleContainer(cappacityOfContainer);
IEnergyModule module0 = new CryogenRod(moduleId, moduleAdditionalParameter);
container.AddEnergyModule(module0);
IAbsorbingModule module1 = new HeatProcessor(moduleId, moduleAdditionalParameter);
container.AddAbsorbingModule(module1);
int expectedModuleCount = 2;
int actuallModuleCount = container.ModulesByInput.Count;
Assert.AreEqual(expectedModuleCount, actuallModuleCount, "Module is not added count not increased");
moduleId++;
container.AddAbsorbingModule(new HeatProcessor(moduleId, moduleAdditionalParameter));
actuallModuleCount = container.ModulesByInput.Count;
Assert.AreEqual(expectedModuleCount, actuallModuleCount, "Module is not added count not increased");
Assert.That(container.ModulesByInput.Where(x => x is IEnergyModule).Count() == 0, "Container does not remove uppon overflow the first to enter");
container.AddEnergyModule(new CryogenRod(moduleId++, moduleAdditionalParameter));
container.AddEnergyModule(new CryogenRod(moduleId, moduleAdditionalParameter));
Assert.That(container.ModulesByInput.Where(x => x is IAbsorbingModule).Count() == 0, "Container does not remove uppon overflow the first to enter");
}
public void AddEnergyModuleTest()
{
int expectedCount = 0;
var moduleContainer = new ModuleContainer(10);
var energyModule = new CryogenRod(1, 100);
moduleContainer.AddEnergyModule(energyModule);
FieldInfo fieldEnergyModules = moduleContainer.GetType()
.GetField("energyModules", BindingFlags.NonPublic | BindingFlags.Instance);
expectedCount = 1;
var actualCount = (IDictionary)fieldEnergyModules.GetValue(moduleContainer);
Assert.AreEqual(expectedCount, actualCount.Count);
// Test modulesByInput
FieldInfo fieldModulesByInput = moduleContainer.GetType()
.GetField("modulesByInput", BindingFlags.NonPublic | BindingFlags.Instance);
var actualCountOfList = (IList)fieldModulesByInput.GetValue(moduleContainer);
expectedCount = 1;
Assert.AreEqual(expectedCount, actualCountOfList.Count);
// Test for null
Assert.That(() => moduleContainer.AddEnergyModule(null), Throws.ArgumentException);
}
public void Test1()
{
var moduleContainer = new ModuleContainer(3);
var absorbingModule = new CooldownSystem(2, 0);
var secondabsorbingModule = new CooldownSystem(5, 100);
var energyModule = new CryogenRod(3, 200);
var secondEnergyModule = new CryogenRod(4, 100);
moduleContainer.AddAbsorbingModule(absorbingModule);
moduleContainer.AddAbsorbingModule(secondabsorbingModule);
moduleContainer.AddEnergyModule(energyModule);
moduleContainer.AddEnergyModule(secondEnergyModule);
var actualTotalHeatAbsorbingResult = moduleContainer.TotalHeatAbsorbing;
var actualTotalEnergyOutput = moduleContainer.TotalEnergyOutput;
var expectedTotalHeatAbsorbingResult = 100;
var expectedTotalEnergyOutput = 300;
var actualModulesByInputCount = moduleContainer.ModulesByInput.Count;
var expectedModulesByInputCount = 3;
Assert.AreEqual(expectedTotalHeatAbsorbingResult, actualTotalHeatAbsorbingResult);
Assert.AreEqual(expectedTotalEnergyOutput, actualTotalEnergyOutput);
Assert.AreEqual(expectedModulesByInputCount, actualModulesByInputCount);
//Assert.AreEqual(actualModulesByInputCount, expectedModulesByInputCount);
//Assert.Throws<ArgumentException>(() => moduleContainer.AddAbsorbingModule(null));
}
public void TestEx()
{
int moduleCapacity = 1;
CryogenRod cryoMod = null;
ModuleContainer testContainer = new ModuleContainer(moduleCapacity);
Assert.Throws <ArgumentException>(() => testContainer.AddEnergyModule(cryoMod));
}
public void When_AddEnergyModuleCall_ShouldRemoveFirstIfCapacityExceeded()
{
CryogenRod second = new CryogenRod(2, 2);
moduleContainer.AddEnergyModule(new CryogenRod(1, 2));
moduleContainer.AddEnergyModule(second);
moduleContainer.AddEnergyModule(new CryogenRod(3, 2));
Assert.AreEqual(second, moduleContainer.ModulesByInput.First());
}
public void AddEnergyModule_ValidModule_ShouldAddCorrectly()
{
IEnergyModule module = new CryogenRod(2, 3);
this.moduleContainer.AddEnergyModule(module);
var expected = 1;
var actual = this.moduleContainer.ModulesByInput.Count;
Assert.AreEqual(expected, actual);
}
public void TestToCreateEnergyModule()
{
var moduleContainer = new ModuleContainer(10);
var module = new CryogenRod(1, 100);
moduleContainer.AddEnergyModule(module);
System.Console.WriteLine(moduleContainer.TotalEnergyOutput);
Assert.That(moduleContainer.TotalEnergyOutput, Is.EqualTo(100));
}
public void TestIfModulesAreBeingAdded()
{
var moduleContainer = new ModuleContainer(5);
var energy = new CryogenRod(3, 13);
var heatProc = new HeatProcessor(3, 14);
moduleContainer.AddAbsorbingModule(heatProc);
moduleContainer.AddEnergyModule(energy);
Assert.That(2, Is.EqualTo(moduleContainer.ModulesByInput.Count));
}
public void TestAddEnergyModulesWithOverCapacity()
{
var capacity = 1;
ModuleContainer moduleContainer = new ModuleContainer(capacity);
var module1 = new CryogenRod(1, 100);
var modele2 = new CryogenRod(2, 200);
var actual = moduleContainer.TotalEnergyOutput;
var expected = 0;
Assert.That(actual, Is.EqualTo(expected));
}
public void Test()
{
int moduleCapacity = 1;
var cryoMod = new CryogenRod(1, 1000);
ModuleContainer testContainer = new ModuleContainer(moduleCapacity);
testContainer.AddEnergyModule(cryoMod);
Assert.AreEqual(testContainer.ModulesByInput.Count, 1);
Assert.AreEqual(testContainer.TotalEnergyOutput, 1000);
Assert.AreEqual(testContainer.TotalHeatAbsorbing, 0);
}
public void TotalEnergyOutput_ShouldReturnCorrectValue()
{
IEnergyModule firstModule = new CryogenRod(1, 2);
IEnergyModule secondModule = new CryogenRod(2, 3);
this.moduleContainer.AddEnergyModule(firstModule);
this.moduleContainer.AddEnergyModule(secondModule);
var expected = 5;
var actual = this.moduleContainer.TotalEnergyOutput;
Assert.AreEqual(expected, actual);
}
public void CheckAddEnergyModule()
{
int cappacityOfContainer = 1;
int moduleId = 1;
int moduleAdditionalParameter = 10;
IContainer container = new ModuleContainer(cappacityOfContainer);
IEnergyModule module0 = new CryogenRod(moduleId, moduleAdditionalParameter);
container.AddEnergyModule(module0);
int expectedModuleCount = 1;
int actuallModuleCount = container.ModulesByInput.Count;
Assert.AreEqual(expectedModuleCount, actuallModuleCount, "Module is not added count not increased");
}
public void AddEnergyModule_RemovesOldestModule()
{
IEnergyModule firstModule = new CryogenRod(1, 2);
IEnergyModule secondModule = new CryogenRod(2, 3);
IEnergyModule thirdModule = new CryogenRod(3, 4);
IEnergyModule fourthModule = new CryogenRod(4, 5);
this.moduleContainer.AddEnergyModule(firstModule);
this.moduleContainer.AddEnergyModule(secondModule);
this.moduleContainer.AddEnergyModule(thirdModule);
this.moduleContainer.AddEnergyModule(fourthModule);
Assert.AreEqual(3, this.moduleContainer.ModulesByInput.Count);
}
public void TestingEnergy()
{
var moduleContainer = new ModuleContainer(5);
var energy = new CryogenRod(3, 13);
var energy3 = new CryogenRod(5, 133);
moduleContainer.AddEnergyModule(energy);
moduleContainer.AddEnergyModule(energy3);
var expectedEnergy = 146;
Assert.That(expectedEnergy, Is.EqualTo(moduleContainer.TotalEnergyOutput));
}
public void TestAddEnergyModules()
{
var capacity = 10;
ModuleContainer moduleContainer = new ModuleContainer(capacity);
IEnergyModule module1 = new CryogenRod(1, 100);
moduleContainer.AddEnergyModule(module1);
var actual = moduleContainer.TotalEnergyOutput;
var expected = 100;
Assert.That(actual, Is.EqualTo(expected));
}
public void TestingToString()
{
var moduleContainer = new ModuleContainer(5);
var energy = new CryogenRod(3, 13);
var heatProc = new HeatProcessor(3, 14);
moduleContainer.AddAbsorbingModule(heatProc);
moduleContainer.AddEnergyModule(energy);
var expectedEnergy = moduleContainer.TotalEnergyOutput;
Assert.That(expectedEnergy, Is.EqualTo(moduleContainer.TotalEnergyOutput));
}
public void TestAddEnergyModuleValidation()
{
IEnergyModule energyModule = new CryogenRod(1, 15);
this.moduleContainer.AddEnergyModule(energyModule);
//Method should add energyModule
long expectedResult = 15;
long actualResult = this.moduleContainer.TotalEnergyOutput;
Assert.That(actualResult, Is.EqualTo(expectedResult), "Total energy output should be 15");
//Method should throws exceptio if no parameter is provided
Assert.Throws <ArgumentException>(() => this.moduleContainer.AddEnergyModule(null), "Method should throws ArgumentException");
}
public void WhenModuleIsFullRemovesFirst()
{
var moduleContainer = new ModuleContainer(3);
var energy = new CryogenRod(3, 13);
var heatProc = new HeatProcessor(4, 14);
var prces = new HeatProcessor(7, 14);
var cooldown = new CooldownSystem(1, 2);
moduleContainer.AddAbsorbingModule(heatProc);
moduleContainer.AddEnergyModule(energy);
moduleContainer.AddAbsorbingModule(prces);
moduleContainer.AddAbsorbingModule(cooldown);
Assert.That(3, Is.EqualTo(moduleContainer.ModulesByInput.Count));
}
public void AddEnergyModuleShouldRemoveOldestModule()
{
var container = new ModuleContainer(3);
var energyModule1 = new CryogenRod(1, 100);
var energyModule2 = new CryogenRod(2, 100);
var energyModule3 = new CryogenRod(3, 100);
var energyModule4 = new CryogenRod(4, 100);
container.AddEnergyModule(energyModule1);
container.AddEnergyModule(energyModule2);
container.AddEnergyModule(energyModule3);
container.AddEnergyModule(energyModule4);
Assert.AreEqual(300, container.TotalEnergyOutput);
Assert.AreEqual(3, container.ModulesByInput.Count);
Assert.AreEqual(2, container.ModulesByInput.First().Id);
}
// Parameters – reactorId(int), type(string), additionalParameter(int).
public string ModuleCommand(IList <string> arguments)
{
int reactorId = int.Parse(arguments[0]);
string moduleType = arguments[1];
int additionalParameter = int.Parse(arguments[2]);
// Creates a Module of the given type with the next id and adds
// it to the ModuleContainer of the Reactor with the given reactorId.
// The type will either be “CryogenRod”, “HeatProcessor” or “CoolingSystem
int currentId = this.currentId;
// System.Console.WriteLine("CNT (BEFORE): " + this.modules.Count);
switch (moduleType)
{
case "CryogenRod":
IEnergyModule cryogenRod = new CryogenRod(this.currentId, additionalParameter);
// this.currentId++;
this.reactors[reactorId].AddEnergyModule(cryogenRod);
this.identifiableObjects.Add(cryogenRod.Id, cryogenRod);
this.modules.Add(cryogenRod.Id, cryogenRod);
break;
case "HeatProcessor":
IAbsorbingModule heatProcessor = new HeatProcessor(this.currentId, additionalParameter);
// this.currentId++;
this.reactors[reactorId].AddAbsorbingModule(heatProcessor);
this.identifiableObjects.Add(heatProcessor.Id, heatProcessor);
this.modules.Add(heatProcessor.Id, heatProcessor);
break;
case "CooldownSystem":
IAbsorbingModule cooldownSystem = new CooldownSystem(this.currentId, additionalParameter);
// this.currentId++;
this.reactors[reactorId].AddAbsorbingModule(cooldownSystem);
this.identifiableObjects.Add(cooldownSystem.Id, cooldownSystem);
this.modules.Add(cooldownSystem.Id, cooldownSystem);
break;
}
//System.Console.WriteLine("CNT (AFTER): " + this.modules.Count);
string result = string.Format(Constants.ModuleCreateMessage, moduleType, this.currentId++, reactorId);
return(result);
}
public void TotalEnergyOutputProperty()
{
var moduleContainer = new ModuleContainer(10);
var absorbingModule = new HeatProcessor(1, 100);
var energyModule = new CryogenRod(2, 100);
var energyModule2 = new CryogenRod(3, 100);
moduleContainer.AddAbsorbingModule(absorbingModule);
moduleContainer.AddEnergyModule(energyModule);
moduleContainer.AddEnergyModule(energyModule2);
var actualEnergyOutput = moduleContainer.GetType()
.GetProperty("TotalEnergyOutput", BindingFlags.Public | BindingFlags.Instance)
.GetValue(moduleContainer);
var expectedOutput = 200;
Assert.AreEqual(expectedOutput, actualEnergyOutput);
}
public void TestProperties()
{
var capacity = 10;
ModuleContainer moduleContainer = new ModuleContainer(capacity);
var modele1 = new CryogenRod(1, 100);
var module2 = new HeatProcessor(2, 200);
var module3 = new CooldownSystem(3, 300);
moduleContainer.AddEnergyModule(modele1);
moduleContainer.AddAbsorbingModule(module2);
moduleContainer.AddAbsorbingModule(module3);
var actual = moduleContainer.ModulesByInput.Count;
var expected = 3;
Assert.That(actual, Is.EqualTo(expected));
Assert.That(moduleContainer.TotalEnergyOutput, Is.EqualTo(100));
Assert.That(moduleContainer.TotalHeatAbsorbing, Is.EqualTo(500));
}
public void UniqueIdTest()
{
var moduleContainer = new ModuleContainer(10);
var energyModule = new CryogenRod(1, 100);
var energyModule2 = new CryogenRod(2, 100);
moduleContainer.AddEnergyModule(energyModule);
moduleContainer.AddEnergyModule(energyModule2);
var energyModules = (IDictionary)moduleContainer.GetType()
.GetField("energyModules", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(moduleContainer);
var actualIds = energyModules.Keys;
var expectedId = 1;
foreach (var actualId in actualIds)
{
Assert.That(expectedId == (int)actualId);
expectedId++;
}
}
public void RemoveOldestModuleTest()
{
var moduleContainer = new ModuleContainer(10);
var absorbingModule = new HeatProcessor(1, 100);
var energyModule = new CryogenRod(2, 100);
moduleContainer.AddAbsorbingModule(absorbingModule);
moduleContainer.AddEnergyModule(energyModule);
MethodInfo removeOldestModule = moduleContainer.GetType()
.GetMethod("RemoveOldestModule", BindingFlags.NonPublic | BindingFlags.Instance);
FieldInfo fieldAbsorbingModules = moduleContainer.GetType()
.GetField("absorbingModules", BindingFlags.NonPublic | BindingFlags.Instance);
FieldInfo fieldEnergyModules = moduleContainer.GetType()
.GetField("energyModules", BindingFlags.NonPublic | BindingFlags.Instance);
var energyModuleField = (IDictionary)fieldEnergyModules.GetValue(moduleContainer);
var expectedResultForEnergyModule = 1;
var absorbingModules = (IDictionary)fieldAbsorbingModules.GetValue(moduleContainer);
var expectedForAbsorbingModules = 0;
removeOldestModule.Invoke(moduleContainer, null);
FieldInfo fieldModulesByInput = moduleContainer.GetType()
.GetField("modulesByInput", BindingFlags.NonPublic | BindingFlags.Instance);
var actualValue = (IList)fieldModulesByInput.GetValue(moduleContainer);
var expected = 1;
Assert.AreEqual(expectedResultForEnergyModule, energyModuleField.Count);
Assert.AreEqual(expectedForAbsorbingModules, absorbingModules.Count);
Assert.AreEqual(expected, actualValue.Count);
}
