public void ToStringValidationWithParts()
{
string actualResult = vehicle.ToString();
string expectedResult = "Revenger - A256\r\nTotal Weight: 2500.000\r\nTotal Price: 8000.000\r\nAttack: 2000\r\nDefense: 1500\r\nHitPoints: 1000\r\nParts: None";
Assert.AreEqual(expectedResult, actualResult);
}
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 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 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"));
}
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 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 ValidateReturnString()
{
var vehicle = new Revenger("Model1", 100, 100, 10, 10, 10, new VehicleAssembler());
StringBuilder result = new StringBuilder();
result.AppendLine($"Revenger - Model1");
result.AppendLine($"Total Weight: {100:F3}");
result.AppendLine($"Total Price: {100:F3}");
result.AppendLine($"Attack: {10}");
result.AppendLine($"Defense: {10}");
result.AppendLine($"HitPoints: {10}");
result.Append("Parts: None");
Assert.That(vehicle.ToString(), Is.EqualTo(result.ToString()));
var attackPart = new ArsenalPart("ArsenalModel", 1.5, 2.5m, 10);
var shellPart = new ShellPart("ShellModel", 1.5, 2.5m, 15);
var endurancePart = new EndurancePart("EnduranceModel", 1.5, 2.5m, 20);
vehicle.AddEndurancePart(endurancePart);
vehicle.AddArsenalPart(attackPart);
vehicle.AddShellPart(shellPart);
result.Clear();
result.AppendLine($"Revenger - Model1");
result.AppendLine($"Total Weight: {104.5:F3}");
result.AppendLine($"Total Price: {107.5:F3}");
result.AppendLine($"Attack: {20}");
result.AppendLine($"Defense: {25}");
result.AppendLine($"HitPoints: {30}");
result.Append("Parts: EnduranceModel, ArsenalModel, ShellModel");
Assert.That(vehicle.ToString(), Is.EqualTo(result.ToString()));
}
public void Test2()
{
var vehicle = new Revenger("sa", 100, 200, 1000, 500, 2000, new VehicleAssembler());
Assert.That(vehicle.TotalWeight, Is.EqualTo(100));
Assert.That(vehicle.TotalWeight, Is.EqualTo(100));
Assert.That(vehicle.TotalDefense, Is.EqualTo(500));
Assert.That(vehicle.TotalPrice, Is.EqualTo(200));
Assert.That(vehicle.TotalAttack, Is.EqualTo(1000));
Assert.That(vehicle.Model, Is.EqualTo("sa"));
var result = vehicle.ToString();
string expected = "Revenger - sa\r\nTotal Weight: 100.000\r\nTotal Price: 200.000\r\nAttack: 1000\r\nDefense: 500\r\nHitPoints: 2000\r\nParts: None";
Assert.That(result, Is.EqualTo(expected));
}
public void TestAddPartCorrectly()
{
IAssembler assembler = new VehicleAssembler();
Revenger revenger = new Revenger("Test", 100, 100, 100, 100, 100, assembler);
ArsenalPart arsenalPart = new ArsenalPart("Arsenal", 23, 50, 5);
EndurancePart endurancePart = new EndurancePart("Endurance", 23, 50, 5);
ShellPart shellPart = new ShellPart("Shell", 23, 50, 5);
Assert.DoesNotThrow(() => revenger.AddArsenalPart(arsenalPart));
Assert.DoesNotThrow(() => revenger.AddEndurancePart(endurancePart));
Assert.DoesNotThrow(() => revenger.AddShellPart(shellPart));
string actualResult = revenger.ToString();
string expectedResult = "Revenger - Test\r\nTotal Weight: 169.000\r\nTotal Price: 250.000\r\nAttack: 105\r\nDefense: 105\r\nHitPoints: 105\r\nParts: Arsenal, Endurance, Shell";
Assert.AreEqual(actualResult, expectedResult);
}
public void ToStringTest()
{
IPart part = new ArsenalPart("Arsenal", 2, 2, 2);
IAssembler assembler = new VehicleAssembler();
assembler.AddArsenalPart(part);
assembler.AddArsenalPart(part);
assembler.AddEndurancePart(new EndurancePart("22", 22, 22, 22));
assembler.AddShellPart(new ShellPart("ss", 22, 22, 22));
IVehicle vehicle = new Revenger("Revenger", 22, 22, 22, 22, 22, assembler);
string actual = vehicle.ToString();
string excpected = "Revenger - Revenger\r\nTotal Weight: 70.000\r\nTotal Price: 70.000\r\nAttack: 26\r\nDefense: 44\r\nHitPoints: 44\r\nParts: None";
Assert.That(() => actual, Is.EqualTo(excpected));
}
public void Test3()
{
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.ToString();
var expected = @"Revenger - Pesho
Total Weight: 126.000
Total Price: 27.000
Attack: 135
Defense: 125
HitPoints: 124
Parts: TestPart1, TestPart2, TestPart3";
Assert.That(actual, Is.EqualTo(expected));
}
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 ToString_ShouldReturnTheCorrectString(string model,
double weight, decimal price, int attack, int defense, int hitPoints)
{
var vehicle = new Revenger(model, weight, price, attack, defense,
hitPoints, new VehicleAssembler());
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: None");
var expected = result.ToString();
var actual = vehicle.ToString();
Assert.AreEqual(expected, actual);
}
public void DoesStringBuilderWorksCorrect()
{
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);
StringBuilder result = new StringBuilder();
result.AppendLine($"Revenger - aaa");
result.AppendLine($"Total Weight: 1.000");
result.AppendLine($"Total Price: 1.000");
result.AppendLine($"Attack: 1");
result.AppendLine($"Defense: 1");
result.AppendLine($"HitPoints: 1");
result.Append("Parts: ");
StringBuilder partsString = new StringBuilder();
if (partsString.Length > 0)
{
string textToAppend = partsString.ToString()
.Substring(0, partsString.Length - 2);
result.Append(textToAppend);
}
else
{
result.Append("None");
}
Assert.AreEqual(result.ToString(), revenger.ToString());
}
