static void Main(string[] args)
{
//6,6 as dimensions because end position is 5,1 and as array is 0 based it has to be 6
LawnField field = new LawnField(6, 6);
Position mower1Position = new Position(new Ubication(1, 2), new Direction("N"));
Position mower2Position = new Position(new Ubication(3, 3), new Direction("E"));
InstructionList mower1ListOfInstructions = new InstructionList("LMLMLMLMM");
InstructionList mower2ListOfInstructions = new InstructionList("MMRMMRMRRM");
Mower mower1 = new Mower(mower1Position, mower1ListOfInstructions);
Mower mower2 = new Mower(mower2Position, mower2ListOfInstructions);
mower1.NewFieldToBeOperated(field);
mower2.NewFieldToBeOperated(field);
mower1.OperateField();
Console.WriteLine(mower1.GetPosition());
ACMEMower ACMEmower = new Mower();
ACMEmower.SaySomething();
mower1.AskTheField();
mower2.OperateField();
Console.WriteLine(mower2.GetPosition());
mower1.SaySomething();
mower2.AskTheField();
Console.Read();
}
private Mower CreateNewMower(Garden garden, int startX, int startY, Orientation orientation)
{
var newMower = new Mower(garden);
newMower.Start(new Position(new Coordinates(startX, startY), orientation));
return(newMower);
}
public void Mower_ToString_ShouldReturnCorrectOutput()
{
Mower mower = new Mower("Husquarna 350", 10.5, 1.7, 100.55);
string text = mower.ToString();
Assert.AreEqual("Ich heiße Husquarna 350 und kann maximal 100,55 m² Rasen mit 1,7 km/H mähen", mower.ToString());
}
public static INavigator Create(Mower mower, char instruction)
{
switch (instruction)
{
case 'L':
{
return(new HeadingChangeLeft(mower));
}
case 'R':
{
return(new HeadingChangeRight(mower));
}
case 'M':
{
return(new MoveForward(mower));
}
default:
{
throw new Exception("Unknown instruction");
}
}
}
private Mower StartMower(int gardenLength, int gardenWidth, int startX, int startY, Orientation orientation)
{
var mower = new Mower(new Garden(gardenLength, gardenWidth));
mower.Start(new Position(new Coordinates(startX, startY), orientation));
return(mower);
}
public static IMover Create(Mower mower)
{
switch (mower.Position.Heading)
{
case "N":
{
return(new MoveNorth(mower));
}
case "E":
{
return(new MoveEast(mower));
}
case "S":
{
return(new MoveSouth(mower));
}
case "W":
{
return(new MoveWest(mower));
}
default:
{
throw new Exception("Unknown heading");
}
}
}
public void Input_And_Output()
{
string input = @"5 5
1 2 N
LMLMLMLMM
3 3 E
MMRMMRMRRM";
string[] inputLines = input.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
IList <Mower> mowers = new List <Mower>();
Lawn lawn = Lawn.Create(inputLines[0]);
RemoteControl remoteControl = new RemoteControl();
for (int i = 1; i < inputLines.Length - 1; i += 2)
{
Mower mower = new Mower(lawn.Border);
mower.Deploy(inputLines[i]);
remoteControl.ConnectMower(mower);
remoteControl.Send(inputLines[i + 1]);
mowers.Add(mower);
}
Assert.That(mowers.Count, Is.EqualTo(2));
Assert.That(mowers[0].Status, Is.EqualTo("1 3 N"));
Assert.That(mowers[1].Status, Is.EqualTo("5 1 E"));
}
public void ShouldMoveForwardOffCommand()
{
var mower = new Mower(0, 0, 0);
mower.RunCommand("MM");
Assert.That(mower.Position.Y, Is.EqualTo(2));
}
public void ShouldMoveRightOffCommand()
{
var mower = new Mower(0, 0, 0);
mower.RunCommand("RRR");
Assert.That(mower.Direction, Is.EqualTo(3));
}
public void ShouldMoveLeftOffCommand()
{
var mower = new Mower(0, 0, 0);
mower.RunCommand("LL");
Assert.That(mower.Direction, Is.EqualTo(2));
}
public void Move_ValidMoveOneSpace_MowerMovesOneSpace(Heading heading, string expected)
{
var mower = new Mower(new Point(3,3), heading, new Point(5,5));
var result = mower.Move("M");
Assert.AreEqual(expected, result);
}
public void Move_InvalidMoveOneSpaceValidTurn_MowerDoesnNotMoveButDoesTurn(int spx, int spy, Heading heading, int gbx, int gby, string instructions, string expected)
{
var mower = new Mower(new Point(spx,spy), heading, new Point(gbx,gby));
var result = mower.Move(instructions);
Assert.AreEqual(expected, result);
}
public void Mower_Instantiate_IncorrectPower_PropertiesShouldBeCorrect()
{
Mower mower = new Mower("Husquarna 350", -34, 1.7, 100.55);
Assert.AreEqual("Husquarna 350", mower.Name);
Assert.AreEqual(0, mower.Power, 0.001);
Assert.AreEqual(1.7, mower.MaxSpeed, 0.001);
Assert.AreEqual(100.55, mower.MaxArea, 0.001);
}
public void ShouldMoveNorth()
{
var mower = new Mower(0, 0, 0);
mower.MoveForward();
Assert.That(mower.Position.Y, Is.EqualTo(1));
Assert.That(mower.Position.X, Is.EqualTo(0));
}
public void When_Mower_Position_Is_Valid_Then_Mower_Is_Deployed()
{
Border border = new Border(5, 5);
Mower mower = new Mower(border);
mower.Deploy("1 2 N");
Assert.IsTrue(mower.IsDeployed);
}
public void setMowerPosition(Mower mower)
{
int mowerPositionY = mower.position.getUbication().GetUbicationY();
int mowerPositionX = mower.position.getUbication().GetUbicationX();
ClearMowerPosition();
field[mowerPositionY, mowerPositionX] = 1;
}
public void ShouldRunFullCommand1()
{
var mower = new Mower(3, 3, 1);
mower.RunCommand("MMRMMRMRRM");
Assert.That(mower.Position.X, Is.EqualTo(5));
Assert.That(mower.Position.Y, Is.EqualTo(1));
Assert.That(mower.Direction, Is.EqualTo(1));
}
public void ShouldRunFullCommand()
{
var mower = new Mower(1, 2, 0);
mower.RunCommand("LMLMLMLMM");
Assert.That(mower.Position.X, Is.EqualTo(1));
Assert.That(mower.Position.Y, Is.EqualTo(3));
Assert.That(mower.Direction, Is.EqualTo(0));
}
/// <summary>
/// Move mower right
/// </summary>
/// <param name="mower"></param>
internal static void MoveRight(this Mower mower)
{
if (mower.Direction == 3)
{
mower.Direction = 0;
}
else
{
mower.Direction += 1;
}
}
/// <summary>
/// Move mower left
/// </summary>
/// <param name="mower"></param>
internal static void MoveLeft(this Mower mower)
{
if (mower.Direction == 0)
{
mower.Direction = 3;
}
else
{
mower.Direction -= 1;
}
}
public void ShouldMoveWest()
{
var mower = new Mower(1, 1, 0);
mower.MoveRight();
mower.MoveRight();
mower.MoveRight();
mower.MoveForward();
Assert.That(mower.Position.Y, Is.EqualTo(1));
Assert.That(mower.Position.X, Is.EqualTo(0));
}
public void Robots_GetAt_NegativeIndex_ShouldReturnNull()
{
Robots robots = new Robots();
Drone dron = new Drone("Drone1", 10.5, 100.5);
Mower mower = new Mower("Mower", 6.3, 1.2, 250.22);
bool ok = robots.AddRobot(dron);
ok = robots.AddRobot(mower);
Robot robot = robots.GetAt(-1);
Assert.IsNull(robot, "Roboter an negativem Index sollte null sein.");
}
public void ShouldMoveLeft()
{
var mower = new Mower(0, 0, 0);
mower.MoveLeft();
Assert.That(mower.Direction, Is.EqualTo(3));
mower.MoveLeft();
Assert.That(mower.Direction, Is.EqualTo(2));
mower.MoveLeft();
Assert.That(mower.Direction, Is.EqualTo(1));
mower.MoveLeft();
Assert.That(mower.Direction, Is.EqualTo(0));
}
public void Robots_Filter_NotMatchingFilter_ShouldReturnNone()
{
Robots robots = new Robots();
Drone dron = new Drone("Drone", 10.5, 100.5);
Mower mower = new Mower("Mower", 6.3, 1.2, 250);
DrivingRobot funCar = new DrivingRobot("FunCar", 33.5, 55.5);
bool ok = robots.AddRobot(mower);
ok = robots.AddRobot(dron);
ok = robots.AddRobot(funCar);
Robot[] filteredRobots = robots.GetByFilter("Terminator");
Assert.AreEqual(0, filteredRobots.Length, "Länge des Arrays stimmt nicht");
}
public void Robots_Add_WithSameName_ShouldNotAddDuplicate()
{
Robots robots = new Robots();
Drone dron = new Drone("Drone", 10.5, 100.5);
Mower mower = new Mower("Mower", 6.3, 1.2, 250);
Mower mower2 = new Mower("Mower", 4.3, 1.7, 200);
DrivingRobot funCar = new DrivingRobot("FunCar", 33.5, 55.5);
bool ok = robots.AddRobot(mower);
ok = robots.AddRobot(dron);
ok = robots.AddRobot(funCar);
ok = robots.AddRobot(mower2);
Assert.IsFalse(ok, "Der Name Mower existiert bereits");
}
public void Robots_Filter_UpperCase_ShouldReturnCorrectResult()
{
Robots robots = new Robots();
Drone dron = new Drone("Drone", 10.5, 100.5);
Mower mower = new Mower("Mower", 6.3, 1.2, 250);
DrivingRobot funCar = new DrivingRobot("FunCar", 33.5, 55.5);
bool ok = robots.AddRobot(mower);
ok = robots.AddRobot(dron);
ok = robots.AddRobot(funCar);
Robot[] filteredRobots = robots.GetByFilter("MOWER");
Assert.AreEqual(1, filteredRobots.Length, "Länge des Arrays stimmt nicht");
Assert.AreEqual("Mower", filteredRobots[0].Name, "Name des gefilterten Roboters stimmt nicht");
}
public void Robots_OperatorPlus_OneListEmpty_ShouldBeCorrectUnion()
{
Robots robots1 = new Robots();
Robots robots2 = new Robots();
Drone dron = new Drone("Drone", 10.5, 100.5);
Mower mower = new Mower("Mower", 6.3, 1.2, 250);
bool ok = robots1.AddRobot(mower);
ok = robots1.AddRobot(dron);
Robots union = robots1 + robots2;
Assert.AreEqual(2, union.Count, "Anzahl Roboter nicht korrekt.");
Assert.AreEqual("Drone", union.GetAt(0).Name, "Roboter an Position 1 wurde falsch zurückgegeben");
Assert.AreEqual("Mower", union.GetAt(1).Name, "Roboter an Position 3 wurde falsch zurückgegeben");
}
public void Robots_Add_TwoRobotsInWrongOrder_ShouldBeCorrectOrder()
{
Robots robots = new Robots();
Drone dron = new Drone("Drone", 10.5, 100.5);
Mower mower = new Mower("Mower", 6.3, 1.2, 250);
bool ok = robots.AddRobot(mower);
ok = robots.AddRobot(dron);
Assert.IsTrue(ok);
Robot robot = robots.GetAt(0);
Assert.AreEqual("Drone", robot.Name, "Roboter an Position 0 wurde falsch zurückgegeben");
robot = robots.GetAt(1);
Assert.AreEqual("Mower", robot.Name, "Roboter an Position 1 wurde falsch zurückgegeben");
}
public void Robots_Filter_EmptyFilter_ShouldReturnAll()
{
Robots robots = new Robots();
Drone dron = new Drone("Drone", 10.5, 100.5);
Mower mower = new Mower("Mower", 6.3, 1.2, 250);
DrivingRobot funCar = new DrivingRobot("FunCar", 33.5, 55.5);
bool ok = robots.AddRobot(mower);
ok = robots.AddRobot(dron);
ok = robots.AddRobot(funCar);
Robot[] filteredRobots = robots.GetByFilter("");
Assert.AreEqual(3, filteredRobots.Length, "Länge des Arrays stimmt nicht");
Assert.AreEqual("FunCar", filteredRobots[0].Name, "Roboter an Position 0 wurde falsch zurückgegeben");
Assert.AreEqual("Drone", filteredRobots[1].Name, "Roboter an Position 1 wurde falsch zurückgegeben");
Assert.AreEqual("Mower", filteredRobots[2].Name, "Roboter an Position 2 wurde falsch zurückgegeben");
}
public void Robots_GetSumOfPower_FourRobots_ShouldReturnCorrectPower()
{
Robots robots = new Robots();
Drone dron = new Drone("Drone1", 10.5, 100.5);
Mower mower = new Mower("Mower", 6.5, 1.2, 250);
Mower mower2 = new Mower("Mower2", 8.3, 1.2, 255.5);
DrivingRobot funCar = new DrivingRobot("FunCar", 33.5, 55.5);
bool ok = robots.AddRobot(mower);
ok = robots.AddRobot(dron);
ok = robots.AddRobot(funCar);
ok = robots.AddRobot(mower2);
double sumOfPower = robots.GetSumOfPower();
Assert.AreEqual(58.8, sumOfPower, 0.001, "Summe der Leistung stimmt nicht");
}
public void Robots_GetSumOfArea_FourRobots_ShouldReturnCorrectArea()
{
Robots robots = new Robots();
Drone dron = new Drone("Drone1", 10.5, 100.5);
Mower mower = new Mower("Mower", 6.3, 1.2, 250.22);
Mower mower2 = new Mower("Mower2", 8.3, 1.2, 255.5);
DrivingRobot funCar = new DrivingRobot("FunCar", 33.5, 55.5);
bool ok = robots.AddRobot(mower);
ok = robots.AddRobot(dron);
ok = robots.AddRobot(funCar);
ok = robots.AddRobot(mower2);
double sumOfArea = robots.GetSumOfArea();
Assert.AreEqual(505.72, sumOfArea, 0.001, "Summe der mähbaren Fläche stimmt nicht");
}
public bool CreateMower(MowerCreate model)
{
var entity =
new Mower()
{
LandscapeId = _userId,
MowerName = model.MowerName,
MowerCity = model.MowerCity,
MowerRate = model.MowerRate,
MowerService = model.MowerService
};
using (var ctx = new ApplicationDbContext())
{
ctx.Mowers.Add(entity);
return(ctx.SaveChanges() == 1);
}
}