public void ValidateCalculatedProperty()
{
IVehicle vehicle = new Vanguard("SA-203", 100.00, 300m, 1000, 450, 2000, new VehicleAssembler());
IPart arsenalPart = new ArsenalPart("Cannon-KA2", 300, 500, 450);
IPart shellPart = new ShellPart("Shields-PI1", 200, 1000, 750);
IPart endurancePart = new EndurancePart("endurance", 200, 1000, 750);
double actualResultTotalWeight = 100;
Assert.AreEqual(actualResultTotalWeight, vehicle.TotalWeight);
decimal actualResultTotalPrice = 300;
Assert.AreEqual(actualResultTotalPrice, vehicle.TotalPrice);
long actualResultTotalAttack = 1000;
Assert.AreEqual(actualResultTotalAttack, vehicle.TotalAttack);
long actualResultTotalDefense = 450;
Assert.AreEqual(actualResultTotalDefense, vehicle.TotalDefense);
long actualResultTotalHitPoints = 2000;
Assert.AreEqual(actualResultTotalHitPoints, vehicle.TotalHitPoints);
}
public void TestMethods()
{
// All Valid
var vehicle = new Vanguard("SA-203", 100, 300, 1000, 450, 2000, new VehicleAssembler());
var arsenalPart = new ArsenalPart("Arsenal", 100, 300, 1000);
var shellPart = new ShellPart("Shell", 100, 300, 1000);
var shellTwoPart = new ShellPart("Shell2", 100, 300, 1000);
var endurancePart = new EndurancePart("Endurance", 100, 300, 1000);
// Test If AddArsenalPart adds new part
vehicle.AddArsenalPart(arsenalPart);
// Test If AddShellPart adds new part
vehicle.AddShellPart(shellPart);
vehicle.AddShellPart(shellTwoPart);
// Test if AddEndurancePart adds new part
vehicle.AddEndurancePart(endurancePart);
var partsList = (List <IPart>)vehicle.Parts;
string[] modelsList = new string[] { "Arsenal", "Shell", "Shell2", "Endurance" };
var typesList = new string[] { "ArsenalPart", "ShellPart", "ShellPart", "EndurancePart" };
for (int index = 0; index < partsList.Count; index++)
{
Assert.AreEqual(partsList[index].Model, modelsList[index]);
Assert.AreEqual(partsList[index].GetType().Name, typesList[index], "Incorrect part type!");
}
}
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 BaseVehicleTest()
{
IAssembler assembler = new VehicleAssembler();
IVehicle vanguard = new Vanguard("Vanguard1", 500, 1000, 500, 500, 1000, assembler);
IPart arsenalPart = new ArsenalPart("Arsenal1", 100, 100, 100);
IPart shellPart = new ShellPart("Shell1", 100, 100, 100);
IPart endurancePart = new EndurancePart("Endurance1", 100, 100, 100);
vanguard.AddArsenalPart(arsenalPart);
vanguard.AddEndurancePart(endurancePart);
vanguard.AddShellPart(shellPart);
double totalWeight = vanguard.TotalWeight;
decimal totalPrice = vanguard.TotalPrice;
long totalAttack = vanguard.TotalAttack;
long totalDefense = vanguard.TotalDefense;
long totalHitPoints = vanguard.TotalHitPoints;
Assert.That(totalWeight, Is.EqualTo(800).NoClip);
Assert.That(totalPrice, Is.EqualTo(1300).NoClip);
Assert.That(totalAttack, Is.EqualTo(600).NoClip);
Assert.That(totalDefense, Is.EqualTo(600).NoClip);
Assert.That(totalHitPoints, Is.EqualTo(1100).NoClip);
string expectedResult = "Vanguard - Vanguard1\r\nTotal Weight: 800.000\r\nTotal Price: 1300.000\r\nAttack: 600\r\nDefense: 600\r\nHitPoints: 1100\r\nParts: Arsenal1, Endurance1, Shell1";
string actualResult = vanguard.ToString();
Assert.That(expectedResult, Is.EqualTo(actualResult).NoClip);
}
public VanguardTests()
{
TestCase testcase = new TestCase {
Id = Guid.NewGuid()
};
this.dataCollectionContext = new DataCollectionContext(testcase);
this.dataCollectionLoggerMock = new Mock <IDataCollectionLogger>();
this.processJobObject = new ProcessJobObject();
this.vanguardCommandBuilderMock = new Mock <IVanguardCommandBuilder>();
this.vanguardLocationProviderMock = new Mock <IProfilersLocationProvider>();
this.vanguard = new Vanguard(this.vanguardLocationProviderMock.Object, this.vanguardCommandBuilderMock.Object, this.processJobObject);
this.sessionName = Guid.NewGuid().ToString();
this.configFileName = string.Format(VanguardTests.ConfigFileNameFormat, Path.GetTempPath(), this.sessionName);
this.outputDir = Path.GetDirectoryName(this.configFileName);
Directory.CreateDirectory(this.outputDir);
File.WriteAllText(this.configFileName, VanguardTests.ConfigXml);
this.outputFileName = Path.Combine(this.outputDir, Guid.NewGuid() + ".coverage");
this.vanguardCommandBuilderMock.Setup(c =>
c.GenerateCommandLine(VanguardCommand.Shutdown, this.sessionName, It.IsAny <string>(), It.IsAny <string>()))
.Returns(VanguardTests.GetShutdownCommand(this.sessionName));
this.vanguard.Initialize(this.sessionName, this.configFileName, this.dataCollectionLoggerMock.Object);
this.vanguardLocationProviderMock.Setup(c => c.GetVanguardPath()).Returns(Path.Combine(Directory.GetCurrentDirectory(), "CodeCoverage", "CodeCoverage.exe"));
}
public void ToStringShouldReturnProperString()
{
IAssembler assembler = new VehicleAssembler();
IVehicle vehicle = new Vanguard(model, weight, price, attack, defense, hitPoints, assembler);
string result = "Vanguard - bleh\r\nTotal Weight: 30.000\r\nTotal Price: 40.000\r\nAttack: 50\r\nDefense: 60\r\nHitPoints: 70\r\nParts: None";
Assert.That(vehicle.ToString(), Is.EqualTo(result));
}
public void ShouldAddArsenalPart()
{
IPart arsenalPart = new ArsenalPart(partModel, partWeight, partPrice, attackMod);
IVehicle vehicle = new Vanguard(model, weight, price, attack, defense, hitPoints, assembler);
vehicle.AddArsenalPart(arsenalPart);
Assert.That(vehicle.TotalAttack > 50);
}
public void CheckIfInstantiationWorksProperly()
{
IVehicle vehicle = new Vanguard(model, weight, price, attack, defense, hitPoints, assembler);
string actualResult = vehicle.ToString();
string expectedResult = "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.That(actualResult, Is.EqualTo(expectedResult));
}
public void CheckPartsAddition()
{
IVehicle vehicle = new Vanguard("KillingMachine", 123, 3446m, 9000, 876, 56, new VehicleAssembler());
vehicle.AddArsenalPart(new ArsenalPart("arsenalModel", 5.3, 20.45m, 32));
vehicle.AddShellPart(new ShellPart("shellModel", 10, 2000m, 700));
vehicle.AddEndurancePart(new EndurancePart("enduranceModel", 100, 700m, 30));
Assert.That(vehicle.Parts.Count().Equals(3));
}
public void ShouldAddShellPart()
{
IPart shellPart = new ShellPart(partModel, partWeight, partPrice, attackMod);
IVehicle vehicle = new Vanguard(model, weight, price, attack, defense, hitPoints, assembler);
vehicle.AddShellPart(shellPart);
Assert.That(vehicle.TotalDefense > defense);
}
public void ValidateProperties()
{
var revenger = new Vanguard("Reven", 6d, 6m, 6, 6, 6, new VehicleAssembler());
Assert.AreEqual(revenger.Attack, 6, $"Attack property returns invalid result");
Assert.AreEqual(revenger.Defense, 6, $"Defense property returns invalid result");
Assert.AreEqual(revenger.HitPoints, 6, $"HitPoints property returns invalid result");
Assert.AreEqual(revenger.Price, 6, $"Price property returns invalid result");
Assert.AreEqual(revenger.Weight, 6, $"Weight property returns invalid result");
}
public void ShouldAddEndurancePart()
{
IPart endurancePart = new EndurancePart
(partModel, partWeight, partPrice, attackMod);
IVehicle vehicle = new Vanguard(model, weight, price, attack, defense, hitPoints, assembler);
vehicle.AddEndurancePart(endurancePart);
Assert.That(vehicle.TotalHitPoints > hitPoints);
}
public void CheckToString()
{
IVehicle vehicle = new Vanguard("KillingMachine", 123, 3446m, 9000, 876, 56, new VehicleAssembler());
vehicle.AddArsenalPart(new ArsenalPart("arsenalModel", 5.3, 20.45m, 32));
vehicle.AddShellPart(new ShellPart("shellModel", 10, 2000m, 700));
vehicle.AddEndurancePart(new EndurancePart("enduranceModel", 100, 700m, 30));
var actual = vehicle.ToString();
var expected = "Vanguard - KillingMachine\r\nTotal Weight: 238.300\r\nTotal Price: 6166.450\r\nAttack: 9032\r\nDefense: 1576\r\nHitPoints: 86\r\nParts: arsenalModel, shellModel, enduranceModel";
Assert.AreEqual(expected, actual);
}
public void CheckIfWeaponsAreAddedProperly()
{
IVehicle vehicle = new Vanguard(model, weight, price, attack, defense, hitPoints, assembler);
vehicle.AddArsenalPart(new ArsenalPart("test1", 100, 100, 2));
vehicle.AddEndurancePart(new EndurancePart("test2", 200, 200, 3));
vehicle.AddShellPart(new ShellPart("test3", 100, 100, 4));
string actualResult = vehicle.ToString();
string expectedResult = "Vanguard - SA-203\r\nTotal Weight: 500.000\r\nTotal Price: 700.000\r\nAttack: 1002\r\nDefense: 454\r\nHitPoints: 2003\r\nParts: test1, test2, test3";
Assert.That(actualResult, Is.EqualTo(expectedResult));
}
public void ValidateToStringMethod()
{
var revenger = new Vanguard("Reven", 6d, 6m, 6, 6, 6, new VehicleAssembler());
Assert.AreEqual(revenger.Attack, 6, $"Attack property returns invalid result");
Assert.AreEqual(revenger.Defense, 6, $"Defense property returns invalid result");
Assert.AreEqual(revenger.HitPoints, 6, $"HitPoints property returns invalid result");
Assert.AreEqual(revenger.Price, 6, $"Price property returns invalid result");
Assert.AreEqual(revenger.Weight, 6, $"Weight property returns invalid result");
var expected = "Vanguard - Reven\r\nTotal Weight: 6.000\r\nTotal Price: 6.000\r\nAttack: 6\r\nDefense: 6\r\nHitPoints: 6\r\nParts: None";
Assert.AreEqual(revenger.ToString(), expected, $"ToString method returns invalid result.");
}
public void TestBaseVehicleClassReturnsCorrectOutput()
{
//Vehicle Vanguard SA-203 100 300 1000 450 2000
var assembler = new VehicleAssembler();
var vehicle = new Vanguard("SA-203", 100, 300, 1000, 450, 2000, assembler);
var part = new ShellPart("SA-203", 300, 100, 2);
vehicle.AddShellPart(part);
var actualResult = vehicle.ToString();
var expectedResult = "Vanguard - SA-203\r\nTotal Weight: 400.000\r\nTotal Price: 400.000\r\nAttack: 1000\r\nDefense: 452\r\nHitPoints: 2000\r\nParts: SA-203";
Assert.That(actualResult, Is.EqualTo(expectedResult));
}
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 Test1()
{
ArsenalPart arsenalPart = new ArsenalPart("model", 0.5, 2.555m, 20);
ShellPart shellPart = new ShellPart("shell", 2, 3, 5);
EndurancePart endurancePart = new EndurancePart("hp", 2, 3, 6);
Vanguard vanguardVehicle = new Vanguard("moodle", 4, 5, 100, 100, 100, new VehicleAssembler());
vanguardVehicle.AddArsenalPart(arsenalPart);
vanguardVehicle.AddShellPart(shellPart);
vanguardVehicle.AddEndurancePart(endurancePart);
string expected = vanguardVehicle.ToString();
string actual = "Vanguard - moodle\r\nTotal Weight: 8.500\r\nTotal Price: 13.555\r\nAttack: 120\r\nDefense: 105\r\nHitPoints: 106\r\nParts: model, shell, hp";
Assert.AreEqual(expected, actual);
}
public void ValidateAddArsenal()
{
IVehicle vehicle = new Vanguard("SA-203", 100.00, 300m, 1000, 450, 2000, new VehicleAssembler());
IPart arsenalPart = new ArsenalPart("Cannon-KA2", 300, 500, 450);
IPart shellPart = new ShellPart("Shields-PI1", 200, 1000, 750);
IPart endurancePart = new EndurancePart("endurance", 200, 1000, 750);
vehicle.AddArsenalPart(arsenalPart);
vehicle.AddShellPart(shellPart);
vehicle.AddEndurancePart(endurancePart);
Assert.That(vehicle.Parts.ToList().Count == 3);
}
static void Main(string[] args)
{
Bioskop bioskop;
bioskop = new Bloodshot();
bioskop.Film();
Console.WriteLine();
bioskop = new Vanguard();
bioskop.Film();
Console.WriteLine();
bioskop = new Mulan();
bioskop.Film();
Console.ReadKey();
}
public void TestVanguard()
{
Vanguard vehicle = new Vanguard("Kolio", 80, 3M, 1, 1, 1, new VehicleAssembler());
ArsenalPart arsenalPart = new ArsenalPart("Ars1", 10, 3M, 10);
EndurancePart endurancePart = new EndurancePart("End1", 10, 3M, 10);
ShellPart shellPart = new ShellPart("Shell1", 10, 3M, 10);
vehicle.AddArsenalPart(arsenalPart);
vehicle.AddEndurancePart(endurancePart);
vehicle.AddShellPart(shellPart);
int expectedAttack = 11;
int expectedEndurance = 11;
int expectedDefense = 11;
int expectedWeight = 110;
decimal totalPrice = 12M;
List <IPart> orderedParts = new List <IPart>();
orderedParts.Add(arsenalPart);
orderedParts.Add(shellPart);
orderedParts.Add(endurancePart);
StringBuilder result = new StringBuilder();
result.AppendLine($"{vehicle.GetType().Name} - {vehicle.Model}");
result.AppendLine($"Total Weight: {vehicle.TotalWeight:F3}");
result.AppendLine($"Total Price: {vehicle.TotalPrice:F3}");
result.AppendLine($"Attack: {vehicle.TotalAttack}");
result.AppendLine($"Defense: {vehicle.TotalDefense}");
result.AppendLine($"HitPoints: {vehicle.TotalHitPoints}");
result.Append("Parts: ");
result.Append("Ars1, End1, Shell1");
string expectedToString = result.ToString();
string actualToString = vehicle.ToString();
Assert.AreEqual(expectedToString, actualToString);
Assert.AreEqual(expectedAttack, vehicle.TotalAttack);
Assert.AreEqual(expectedEndurance, vehicle.TotalHitPoints);
Assert.AreEqual(expectedDefense, vehicle.TotalDefense);
Assert.AreEqual(expectedWeight, vehicle.TotalWeight);
Assert.AreEqual(totalPrice, vehicle.TotalPrice);
}
static void Main(string[] args)
{
var vanguard = new Vanguard("前锋");
vanguard.Attack();
var center = new Center("中锋");
center.Attack();
center.Defend();
Guards guards = new Guards("后卫");
guards.Defend();
ChineseCenter chineseCenter = new ChineseCenter("适配器");
chineseCenter.Attack();
}
public void CheckIfReturnCorrectResultAfterBattle()
{
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 part3 = new EndurancePart("Shields - PI1", 200, 1000, 750);
tank.AddArsenalPart(part1);
tank2.AddShellPart(part2);
tank2.AddEndurancePart(part3);
var expectedResult = tank2.ToString();
var actualResult = "Revenger - AKU\r\nTotal Weight: 1700.000\r\nTotal Price: 3500.000\r\nAttack: 1450\r\nDefense: 1750\r\nHitPoints: 1750\r\nParts: Shields - PI1, Shields - PI1";
Assert.AreEqual(expectedResult, actualResult);
}
public void IsPriceInitialisedCorrectly()
{
var type = typeof(BaseVehicle);
//string model,double weight,decimal price, int attack,int defense,int hitPoints, IAssembler assembler
string model = "testModel";
double weight = 23;
decimal price = 23m;
int attack = 23;
int defense = 23;
int hitPoints = 23;
VehicleAssembler assembler = new VehicleAssembler();
Vanguard vanguard = new Vanguard(model, weight, price, attack, defense, hitPoints, assembler);
decimal actualValue = vanguard.Price;
decimal expectedValue = 23m;
Assert.AreEqual(expectedValue, actualValue);
}
public void CorrectInitializeVanguardVehicle()
{
// string model, double weight, decimal price, int attack, int defense, int hitPoints, IAssembler assembler
string model = "aaa";
double weight = 1;
decimal price = 1;
int attack = 1;
int defense = 1;
int hitpoint = 1;
var assembler = new VehicleAssembler();
var vanguard = new Vanguard(model, weight, price, attack, defense, hitpoint, assembler);
Assert.AreEqual(model, vanguard.Model);
Assert.AreEqual(weight, vanguard.Weight);
Assert.AreEqual(price, vanguard.Price);
Assert.AreEqual(attack, vanguard.Attack);
Assert.AreEqual(defense, vanguard.Defense);
Assert.AreEqual(hitpoint, vanguard.HitPoints);
}
public void ValidateToString()
{
IVehicle vehicle = new Vanguard("SA-203", 100.00, 300m, 1000, 450, 2000, new VehicleAssembler());
IPart arsenalPart = new ArsenalPart("Cannon-KA2", 300, 500, 450);
IPart shellPart = new ShellPart("Shields-PI1", 200, 1000, 750);
IPart endurancePart = new EndurancePart("endurance", 200, 1000, 750);
vehicle.AddArsenalPart(arsenalPart);
vehicle.AddShellPart(shellPart);
vehicle.AddEndurancePart(endurancePart);
string actualResult = vehicle.ToString();
string expectedResult =
"Vanguard - SA-203\r\nTotal Weight: 800.000\r\nTotal Price: 2800.000\r\nAttack: 1450\r\nDefense: 1200\r\nHitPoints: 2750\r\nParts: Cannon-KA2, Shields-PI1, endurance";
Assert.AreEqual(actualResult, expectedResult);
}
public void GrabAmmo(Vanguard player)
{
//This is the result of waiting for the sound to stop playing
if (m_numShell == 0)
{
return;
}
//I won't bother checking tags here. The Resupply layer collides a player and radar layer. I don't care if the zombies can overrun the resupply stuff.
//Besides, if they occupy the space, the resupply object is practically unusable anyway.
//@todo Maybe I want to come up with an inventory script. Use Vanguard fornow
if (player == null)
{
return;
}
m_numShell = player.GrabAmmo(m_numShell);
if (m_pickUp)
{
m_pickUp.Play();
}
}
public void TestToString()
{
// Test if ToString() returns all the correct result
var vehicle = new Vanguard("SA-203", 100, 300, 1000, 450, 2000, new VehicleAssembler());
var arsenalPart = new ArsenalPart("Arsenal", 100, 300, 1000);
var shellPart = new ShellPart("Shell", 100, 300, 1000);
var shellTwoPart = new ShellPart("Shell2", 100, 300, 1000);
var endurancePart = new EndurancePart("Endurance", 100, 300, 1000);
vehicle.AddArsenalPart(arsenalPart);
vehicle.AddShellPart(shellPart);
vehicle.AddShellPart(shellTwoPart);
vehicle.AddEndurancePart(endurancePart);
var expectedResult = "Vanguard - SA-203\r\nTotal Weight: 500.000\r\nTotal Price: 1500.000\r\nAttack: 2000\r\nDefense: 2450\r\nHitPoints: 3000\r\nParts: Arsenal, Shell, Shell2, Endurance";
var actualResult = vehicle.ToString();
Assert.AreEqual(expectedResult, actualResult);
}
public void TestTheTotalProps()
{
IAssembler assembler = new VehicleAssembler();
assembler.AddArsenalPart(new ArsenalPart("Arsenal", 1, 1, 1));
assembler.AddEndurancePart(new EndurancePart("Endurence", 2, 2, 2));
assembler.AddShellPart(new ShellPart("Shell", 3, 3, 3));
IVehicle revenger = new Revenger("Revenger", 4, 4, 4, 4, 4, assembler);
IVehicle vanguard = new Vanguard("Vanguard", 4, 4, 4, 4, 4, assembler);
Assert.That(() => revenger.TotalWeight, Is.EqualTo(10));
Assert.That(() => revenger.TotalPrice, Is.EqualTo(10));
Assert.That(() => revenger.TotalHitPoints, Is.EqualTo(6));
Assert.That(() => revenger.TotalDefense, Is.EqualTo(7));
Assert.That(() => revenger.TotalAttack, Is.EqualTo(5));
Assert.That(() => vanguard.TotalWeight, Is.EqualTo(10));
Assert.That(() => vanguard.TotalPrice, Is.EqualTo(10));
Assert.That(() => vanguard.TotalHitPoints, Is.EqualTo(6));
Assert.That(() => vanguard.TotalDefense, Is.EqualTo(7));
Assert.That(() => vanguard.TotalAttack, Is.EqualTo(5));
}
public void TestMethods()
{
string model = "Gosho";
double weight = 22.2;
decimal price = 5;
int attack = 3;
int defense = 4;
int hitpoints = 2;
IAssembler assembler = new VehicleAssembler();
var vanguard = new Vanguard(model, weight, price, attack, defense, hitpoints, assembler);
//checks if Parts is empty
var expectedParts = vanguard.Parts.Count();
var actualParts = 0;
Assert.AreEqual(expectedParts, actualParts);
IPart arsenal = new ArsenalPart("123", 33.2, 7, 250);
IPart shell = new ShellPart("123", 33.2, 7, 250);
IPart endurance = new EndurancePart("123", 33.2, 7, 250);
//checks toString() before adding vehicle parts
var expectedBefore = vanguard.ToString();
var actualBefore = "Vanguard - Gosho\r\nTotal Weight: 22.200\r\nTotal Price: 5.000\r\nAttack: 3\r\nDefense: 4\r\nHitPoints: 2\r\nParts: None";
Assert.AreEqual(expectedBefore, actualBefore);
//checks toString() after adding vehicle parts
vanguard.AddArsenalPart(arsenal);
vanguard.AddShellPart(shell);
vanguard.AddEndurancePart(endurance);
var expectedAfter = vanguard.ToString();
var actualAfter = "Vanguard - Gosho\r\nTotal Weight: 121.800\r\nTotal Price: 26.000\r\nAttack: 253\r\nDefense: 254\r\nHitPoints: 252\r\nParts: 123, 123, 123";
Assert.AreEqual(expectedAfter, actualAfter);
//checks Parts list count after adding vehicle parts
Assert.AreEqual(vanguard.Parts.Count(), 3);
}
