public void CheckOverrideToString()
{
string model = "Rhino-CE";
double weight = 12;
decimal price = 19;
int attack = 80;
int defense = 11;
int hitPoints = 3;
IAssembler assembler = new VehicleAssembler();
BaseVehicle testVehicle = new Revenger(model, weight, price, attack, defense, hitPoints, assembler);
IPart arsenalPart = new ArsenalPart("arse1", 1, 1, 2);
testVehicle.AddArsenalPart(arsenalPart);
IPart shellPart = new ShellPart("hel1", 6, 1, 8);
testVehicle.AddShellPart(shellPart);
IPart endurancePart = new EndurancePart("end1", 1, 3, 2);
testVehicle.AddEndurancePart(endurancePart);
string expectedMessage = "Revenger - Rhino-CE\r\nTotal Weight: 20.000\r\nTotal Price: 24.000\r\nAttack: 82\r\nDefense: 19\r\nHitPoints: 5\r\nParts: arse1, hel1, end1";
string actualMessage = testVehicle.ToString();
Assert.AreEqual(expectedMessage, actualMessage);
}
public void CheckIfPropertyThrowException()
{
IVehicle vehicle;
Assert.That(() => vehicle = new Revenger(null, 1, 3, 1, 3, 4, new VehicleAssembler()),
Throws.ArgumentException
.With.Message.EqualTo("Model cannot be null or white space!"));
Assert.That(() => vehicle = new Revenger("asd", -1, 3, 1, 3, 4, new VehicleAssembler()),
Throws.ArgumentException
.With.Message.EqualTo("Weight cannot be less or equal to zero!"));
Assert.That(() => vehicle = new Revenger("asd", 3, -1, 1, 3, 4, new VehicleAssembler()),
Throws.ArgumentException
.With.Message.EqualTo("Price cannot be less or equal to zero!"));
Assert.That(() => vehicle = new Revenger("asd", 3, 3, -3, 3, 4, new VehicleAssembler()),
Throws.ArgumentException
.With.Message.EqualTo("Attack cannot be less than zero!"));
Assert.That(() => vehicle = new Revenger("asd", 3, 3, 3, -3, 4, new VehicleAssembler()),
Throws.ArgumentException
.With.Message.EqualTo("Defense cannot be less than zero!"));
Assert.That(() => vehicle = new Revenger("asd", 3, 3, 3, 3, -4, new VehicleAssembler()),
Throws.ArgumentException
.With.Message.EqualTo("HitPoints cannot be less than zero!"));
}
public string AddVehicle(IList <string> arguments)
{
string vehicleType = arguments[0];
string model = arguments[1];
double weight = double.Parse(arguments[2]);
decimal price = decimal.Parse(arguments[3]);
int attack = int.Parse(arguments[4]);
int defense = int.Parse(arguments[5]);
int hitPoints = int.Parse(arguments[6]);
IVehicle vehicle = null;
switch (vehicleType)
{
case "Vanguard":
vehicle = new Vanguard(model, weight, price, attack, defense, hitPoints, new VehicleAssembler());
break;
case "Revenger":
vehicle = new Revenger(model, weight, price, attack, defense, hitPoints, new VehicleAssembler());
break;
}
if (vehicle != null)
{
this.vehicles.Add(vehicle.Model, vehicle);
}
return(string.Format(
GlobalConstants.VehicleSuccessMessage,
vehicleType,
vehicle.Model));
}
public void Test1()
{
IVehicle vehicle = new Revenger("Model", 5, 5, 5, 5, 5, new VehicleAssembler());
string expectedResult = "Revenger - Model\r\nTotal Weight: 5.000\r\nTotal Price: 5.000\r\nAttack: 5\r\nDefense: 5\r\nHitPoints: 5\r\nParts: None";
string actualResult = vehicle.ToString();
Assert.AreEqual(expectedResult, actualResult);
}
public void Vehicle_ValidParameter_ShouldInitializeCorrectly(string model,
double weight, decimal price, int attack, int defense, int hitPoints)
{
var vehicle = new Revenger(model, weight, price, attack, defense,
hitPoints, new VehicleAssembler());
Assert.IsNotNull(vehicle);
}
public void TestProperties()
{
Assert.That(typeof(BaseVehicle).IsAbstract);
BaseVehicle baseVehicle = new Revenger("MPO", 20, 13, 12, 13, 14, new VehicleAssembler());
Assert.AreEqual(baseVehicle.Model, "MPO");
Assert.AreEqual(baseVehicle.Weight, 20);
Assert.AreEqual(baseVehicle.Price, 13);
Assert.AreEqual(baseVehicle.Attack, 12);
Assert.AreEqual(baseVehicle.Defense, 13);
Assert.AreEqual(baseVehicle.HitPoints, 14);
baseVehicle.AddArsenalPart(new ArsenalPart("Model", 12, 13, 4));
baseVehicle.AddEndurancePart(new EndurancePart("Model2", 14, 15, 6));
baseVehicle.AddShellPart(new ShellPart("Model3", 17, 18, 9));
baseVehicle.AddArsenalPart(new ArsenalPart("Model", 12, 13, 4));
baseVehicle.AddEndurancePart(new EndurancePart("Model2", 14, 15, 6));
baseVehicle.AddShellPart(new ShellPart("Model3", 17, 18, 9));
string actualValue = baseVehicle.ToString();
string[] lines = actualValue.Split(Environment.NewLine);
actualValue = string.Join(Environment.NewLine, lines.Skip(1));
string expectedValue =
"Total Weight: 106,000\r\n" +
"Total Price: 105,000\r\n" +
"Attack: 20\r\n" +
"Defense: 31\r\n" +
"HitPoints: 26\r\n" +
"Parts: Model, Model2, Model3, Model, Model2, Model3";
Assert.AreEqual(expectedValue, actualValue);
FieldInfo fieldInfo = typeof(BaseVehicle).GetField("orderedParts", BindingFlags.Instance | BindingFlags.NonPublic);
IList <string> val = (IList <string>)fieldInfo.GetValue(baseVehicle);
Assert.AreEqual("Model, Model, Model3, Model3, Model2, Model2", string.Join(", ", baseVehicle.Parts.Select(p => p.Model)));
Assert.AreEqual(106.000, baseVehicle.TotalWeight);
Assert.AreEqual(105.000, baseVehicle.TotalPrice);
Assert.AreEqual(20, baseVehicle.TotalAttack);
Assert.AreEqual(31, baseVehicle.TotalDefense);
Assert.AreEqual(26, baseVehicle.TotalHitPoints);
//Assert.AreEqual("Model, Model2, Model3, Model, Model2, Model3", baseVehicle.);
BaseVehicle baseVehicle2 = new Revenger("s", 1, 1, 1, 1, 1, new VehicleAssembler());
Assert.That(() => baseVehicle2 = new Revenger("", 1, 1, 1, 1, 1, new VehicleAssembler()), Throws.ArgumentException);
Assert.That(() => baseVehicle2 = new Revenger("d", 0, 1, 1, 1, 1, new VehicleAssembler()), Throws.ArgumentException);
Assert.That(() => baseVehicle2 = new Revenger("d", 1, 0, 1, 1, 1, new VehicleAssembler()), Throws.ArgumentException);
Assert.That(() => baseVehicle2 = new Revenger("d", 1, 1, -1, 1, 1, new VehicleAssembler()), Throws.ArgumentException);
Assert.That(() => baseVehicle2 = new Revenger("d", 1, 1, 1, -1, 1, new VehicleAssembler()), Throws.ArgumentException);
Assert.That(() => baseVehicle2 = new Revenger("d", 1, 1, 1, 1, -1, new VehicleAssembler()), Throws.ArgumentException);
Assert.AreEqual(true, baseVehicle2.ToString().Contains("None"));
}
// ZeroParams;
public void SuccessfullINitialization()
{
BaseVehicle vehicle = new Revenger("SS", 1000, 1000, 1000, 1000, 1000);
Assert.AreEqual(vehicle.Model, "SS");
Assert.AreEqual(vehicle.Weight, 1000);
Assert.AreEqual(vehicle.HitPoints, 1000);
Assert.AreEqual(vehicle.Model, "SS");
}
public void CheckInvalidExceptions(string model, double weight, decimal price, int attack, int defense, int hitPoints)
{
IAssembler assembler = new VehicleAssembler();
BaseVehicle testVehicle;
Assert.That
(
() => testVehicle = new Revenger(model, weight, price, attack, defense, hitPoints, assembler), Throws.ArgumentException
);
}
public void Test()
{
var vehicle = new Revenger("sa", 100, 200, 1000, 500, 2000, new VehicleAssembler());
Assert.That(vehicle.TotalWeight, Is.EqualTo(100));
Assert.That(() => new Vanguard(null, 10, 20, 30, 40, 50, new VehicleAssembler()), Throws.ArgumentException);
Assert.That(() => new Vanguard("sa", 0, 0, 30, 40, 50, new VehicleAssembler()), Throws.ArgumentException);
}
public void Test1()
{
IVehicle revenger = new Revenger("BMW", 100, 100, 100, 100, 100, new VehicleAssembler());
revenger.AddArsenalPart(new ArsenalPart("M3", 100, 100, 1));
var expectedResult = "Revenger - BMW\r\nTotal Weight: 200.000\r\nTotal Price: 200.000\r\nAttack: 101\r\nDefense: 100\r\nHitPoints: 100\r\nParts: M3";
var actualResult = revenger.ToString();
Assert.AreEqual(expectedResult, actualResult);
}
public void Test3()
{
var vehicle = new Revenger("sa", 100, 200, 1000, 500, 2000, new VehicleAssembler());
vehicle.AddArsenalPart(new ArsenalPart("3", 1, 2, 3));
var result = vehicle.ToString();
string expected = "Revenger - sa\r\nTotal Weight: 101.000\r\nTotal Price: 202.000\r\nAttack: 1003\r\nDefense: 500\r\nHitPoints: 2000\r\nParts: 3";
Assert.That(result, Is.EqualTo(expected));
}
public void Test()
{
IVehicle vehicle = new Revenger("Model", 5, 5, 5, 5, 5, new VehicleAssembler());
IPart arsenalPart = new ArsenalPart("Part", 6, 6, 6);
double weightBefore = vehicle.TotalAttack;
vehicle.AddArsenalPart(arsenalPart);
double weightAfter = vehicle.TotalAttack;
Assert.AreNotEqual(weightBefore, weightAfter);
}
public void CheckIfValueIsSetCorectlly()
{
var vehicle = new Revenger("Model", 1.3, (decimal)4.1, 4, 5, 6, new VehicleAssembler());
var properties = vehicle.GetType().GetProperties();
Assert.That(vehicle.Model == "Model", Is.True);
Assert.That(vehicle.Weight == 1.3, Is.True);
Assert.That(vehicle.Price == (decimal)4.1, Is.True);
Assert.That(vehicle.Attack == 4, Is.True);
Assert.That(vehicle.Defense == 5, Is.True);
Assert.That(vehicle.HitPoints == 6, Is.True);
}
public void ValidateVehicleModel()
{
try
{
IVehicle firstVehicle = new Revenger("Gosho", 112, 12, 12, 12, 12, new VehicleAssembler());
}
catch (Exception ex)
{
var excepctedMessage = "Model cannot be null or white space!";
Assert.AreEqual(excepctedMessage, ex.Message);
}
}
public void Test2()
{
var vehicle = new Revenger("Pesho", 111, 12, 123, 123, 123, new VehicleAssembler());
vehicle.AddArsenalPart(new ArsenalPart("TestPart1", 12, 12, 12));
vehicle.AddShellPart(new ShellPart("TestPart2", 2, 2, 2));
vehicle.AddEndurancePart(new EndurancePart("TestPart3", 1, 1, 1));
var actual = vehicle.Parts.Count();
var expected = 3;
Assert.That(actual, Is.EqualTo(expected));
}
public void ValidateVehiclePartList()
{
IVehicle vehicle = new Revenger("Gosho", 112, 12, 12, 12, 12, new VehicleAssembler());
vehicle.AddArsenalPart(new ArsenalPart("Top", 12, 12, 2));
vehicle.AddArsenalPart(new ArsenalPart("Test", 22, 1, 3));
vehicle.AddEndurancePart(new EndurancePart("Hit", 2, 52, 1));
vehicle.AddShellPart(new ShellPart("Shelche", 2, 52, 1));
var partsCount = vehicle.Parts.Count();
var expectedResult = 4;
Assert.AreEqual(expectedResult, partsCount);
}
public void ASD()
{
IVehicle vehicle = new Revenger("asd", 1, 3, 1, 3, 4, new VehicleAssembler());
long attack = vehicle.TotalAttack;
long defence = vehicle.TotalDefense;
double weight = vehicle.TotalWeight;
long hitpoints = vehicle.TotalHitPoints;
Assert.AreEqual(attack, 1);
Assert.AreEqual(defence, 3);
Assert.AreEqual(weight, 1);
Assert.AreEqual(hitpoints, 4);
;
}
public void VechileToStringMethodShouldrReturnCorrectString()
{
IVehicle vehicle = new Revenger("Gosho", 112, 12, 12, 12, 12, new VehicleAssembler());
vehicle.AddArsenalPart(new ArsenalPart("Top", 12, 12, 2));
vehicle.AddArsenalPart(new ArsenalPart("Test", 22, 1, 3));
vehicle.AddEndurancePart(new EndurancePart("Hit", 2, 52, 1));
vehicle.AddShellPart(new ShellPart("Shelche", 2, 52, 1));
var expectedResult = "Revenger - Gosho\r\nTotal Weight: 150,000\r\nTotal Price: 129,000\r\nAttack: 17\r\nDefense: 13\r\nHitPoints: 13\r\nParts: Top, Test, Hit, Shelche";
var actualResult = vehicle.ToString();
Assert.AreEqual(expectedResult, actualResult);
}
public void Test1ValidateVehicleModel()
{
try
{
var vehicle = new Revenger("", 111, 12, 123, 123, 123, new VehicleAssembler());
}
catch (Exception ex)
{
var expected = "Model cannot be null or white space!";
var actual = ex.Message;
Assert.That(actual, Is.EqualTo(expected));
}
}
public void AddEndurancePartShouldAddThePartToAssembler()
{
//Arrange
var part = new EndurancePart("part", 10, 10, 10);
IAssembler assembler = new VehicleAssembler();
IVehicle vehicle = new Revenger("revenger", 10, 10, 10, 10, 10, assembler);
//Action
vehicle.AddEndurancePart(part);
bool assemblerHasPart = assembler.EnduranceParts.Any(ap => ap.Equals(part));
//Assert
Assert.AreEqual(true, assemblerHasPart);
}
public void CheckToString()
{
IVehicle vehicle = new Revenger("asd", 1, 3, 1, 3, 4, new VehicleAssembler());
var arsenal = new ArsenalPart("asd", 12, 3, 4);
var endurance = new EndurancePart("asd", 3, 3, 4);
var shell = new ShellPart("asd", 3, 3, 4);
vehicle.AddEndurancePart(endurance);
vehicle.AddArsenalPart(arsenal);
vehicle.AddShellPart(shell);
Assert.That(vehicle.Parts, Has.Member(arsenal));
Assert.That(vehicle.Parts, Has.Member(endurance));
Assert.That(vehicle.Parts, Has.Member(shell));
}
public void TotalAttackShouldReturnCorrectValue()
{
var arsenalPart = new ArsenalPart("model", 10, 10, 100);
IAssembler assembler = new VehicleAssembler();
assembler.AddArsenalPart(arsenalPart);
IVehicle v = new Revenger("revenger", 10, 10, 10, 10, 10, assembler);
var expectedVehicleTotal = v.Attack + assembler.TotalAttackModification;
var actualVehicleTotal = v.TotalAttack;
Assert.AreEqual(expectedVehicleTotal, actualVehicleTotal);
}
public void PartsProperty_ShouldReturnCorrectly(string model,
double weight, decimal price, int attack, int defense, int hitPoints)
{
var vehicle = new Revenger(model, weight, price, attack, defense,
hitPoints, new VehicleAssembler());
IPart arsenalPart = new ArsenalPart(model, weight, price, 10);
vehicle.AddArsenalPart(arsenalPart);
var expected = arsenalPart;
var actual = vehicle.Parts.ToList()[0];
Assert.AreSame(expected, actual);
}
public void TotalDefenseShouldReturnCorrectValue()
{
var part = new ShellPart("model", 10, 10, 100);
IAssembler assembler = new VehicleAssembler();
assembler.AddShellPart(part);
IVehicle v = new Revenger("revenger", 10, 10, 10, 10, 10, assembler);
var expectedVehicleTotal = v.Defense + assembler.TotalDefenseModification;
var actualVehicleTotal = v.TotalDefense;
Assert.AreEqual(expectedVehicleTotal, actualVehicleTotal);
}
public void TotalHitPointsShouldReturnCorrectValue()
{
var part = new EndurancePart("model", 10, 10, 100);
IAssembler assembler = new VehicleAssembler();
assembler.AddEndurancePart(part);
IVehicle v = new Revenger("revenger", 10, 10, 10, 10, 10, assembler);
var expectedVehicleTotal = v.HitPoints + assembler.TotalHitPointModification;
var actualVehicleTotal = v.TotalHitPoints;
Assert.AreEqual(expectedVehicleTotal, actualVehicleTotal);
}
public void AddEndurancePart_ShouldAddPartCorrectly(string model,
double weight, decimal price, int attack, int defense, int hitPoints)
{
var vehicle = new Revenger(model, weight, price, attack, defense,
hitPoints, new VehicleAssembler());
IPart endurancePart = new EndurancePart(model, weight, price, 10);
vehicle.AddEndurancePart(endurancePart);
var expected = 1;
var actual = vehicle.Parts.Count();
Assert.AreEqual(expected, actual);
}
public void CheckIfReturnCorrectResult()
{
var assembler = new VehicleAssembler();
var tank = new Vanguard("SA - 203", 100, 300, 1000, 450, 2000, assembler);
var tank2 = new Revenger("AKU", 1000, 1000, 1000, 1000, 1000, assembler);
var part1 = new ArsenalPart("Cannon - KA2", 300, 500, 450);
var part2 = new ShellPart("Shields - PI1", 200, 1000, 750);
var expectedResult = tank.ToString();
var actualResult = "Vanguard - SA - 203\r\nTotal Weight: 100.000\r\nTotal Price: 300.000\r\nAttack: 1000\r\nDefense: 450\r\nHitPoints: 2000\r\nParts: None";
Assert.AreEqual(expectedResult, actualResult);
}
public void DoesTotalDefenseSumIsCorrest()
{
string model = "aaa";
double weight = 1;
decimal price = 1;
int attack = 1;
int defense = 1;
int hitpoint = 1;
var assembler = new VehicleAssembler();
var revenger = new Revenger(model, weight, price, attack, defense, hitpoint, assembler);
var shellpart = new ShellPart("aaa", 1, 1, 100);
revenger.AddShellPart(shellpart);
Assert.AreEqual(101, revenger.TotalDefense);
}
public void DoesTotalHitPointSumIsCorrest()
{
string model = "aaa";
double weight = 1;
decimal price = 1;
int attack = 1;
int defense = 1;
int hitpoint = 1;
var assembler = new VehicleAssembler();
var revenger = new Revenger(model, weight, price, attack, defense, hitpoint, assembler);
var endurance = new EndurancePart("aaa", 1, 1, 100);
revenger.AddEndurancePart(endurance);
Assert.AreEqual(101, revenger.TotalHitPoints);
}
public void TotalWeightShouldReturnCorrectValue()
{
var arsenalPart = new ArsenalPart("model", 100, 10, 10);
IAssembler assembler = new VehicleAssembler();
assembler.AddArsenalPart(arsenalPart);
var assemblerTotalWeight = assembler.TotalWeight;
IVehicle v = new Revenger("revenger", 10, 10, 10, 10, 10, assembler);
var expectedVehicleTotalWeight = v.Weight + assemblerTotalWeight;
var actualVehicleTotalWeigth = v.TotalWeight;
Assert.AreEqual(expectedVehicleTotalWeight, actualVehicleTotalWeigth);
}
