public void ShouldDrawABucket()
{
var canvas = new string[5, 5];
BucketFill bucket = new BucketFill(1, 1);
Assert.IsTrue(bucket.IsValid(canvas));
var drawnCanvas = bucket.DrawToCanvas(canvas);
Assert.IsNotNull(drawnCanvas);
Assert.AreEqual("o", drawnCanvas.GetValue(1, 1));
Assert.AreEqual("o", drawnCanvas.GetValue(1, 2));
Assert.AreEqual("o", drawnCanvas.GetValue(1, 3));
Assert.AreEqual("o", drawnCanvas.GetValue(1, 4));
Assert.AreEqual("o", drawnCanvas.GetValue(2, 1));
Assert.AreEqual("o", drawnCanvas.GetValue(2, 2));
Assert.AreEqual("o", drawnCanvas.GetValue(2, 3));
Assert.AreEqual("o", drawnCanvas.GetValue(2, 4));
Assert.AreEqual("o", drawnCanvas.GetValue(3, 1));
Assert.AreEqual("o", drawnCanvas.GetValue(3, 2));
Assert.AreEqual("o", drawnCanvas.GetValue(3, 3));
Assert.AreEqual("o", drawnCanvas.GetValue(3, 4));
Assert.AreEqual("o", drawnCanvas.GetValue(4, 1));
Assert.AreEqual("o", drawnCanvas.GetValue(4, 2));
Assert.AreEqual("o", drawnCanvas.GetValue(4, 3));
Assert.AreEqual("o", drawnCanvas.GetValue(4, 4));
}
public void DrawBucketFill_BottomOnCanvasWithHorizontalLine_BottomSideCanvasFilled()
{
string[] expected = new string[]
{
"----------------------",
"| |",
"| |",
"|xxxxxxxxxxxxxxxxxxxx|",
"|cccccccccccccccccccc|",
"|cccccccccccccccccccc|",
"----------------------"
};
Canvas canvas = new Canvas(20, 5);
Line horizontalLine = new Line(1, 3, 20, 3);
canvas.Shapes.Add(horizontalLine);
canvas.Draw();
BucketFill bucketFillBottomCanvas = new BucketFill(5, 4, "c");
string[] actual = bucketFillBottomCanvas.Draw(canvas);
CollectionAssert.AreEqual(expected, actual);
}
public void ShouldNotAllowIfXIsOutOfCanvas()
{
string[,] canvas = new string[5, 5];
BucketFill bucket = new BucketFill(6, 3);
Assert.IsFalse(bucket.IsValid(canvas));
}
public void ShouldNotAllowIfYIsOutOfCanvas()
{
var canvas = new string[5, 5];
BucketFill bucket = new BucketFill(1, 10);
Assert.IsFalse(bucket.IsValid(canvas));
}
public void DrawBucketFill_OutsideRectangle_RectangleFilled()
{
string[] expected = new string[]
{
"----------------------",
"|cccccccccccccccccccc|",
"|ccxxxxxccccccccccccc|",
"|ccx xccccccccccccc|",
"|ccx xccccccccccccc|",
"|ccxxxxxccccccccccccc|",
"----------------------"
};
Canvas canvas = new Canvas(20, 5);
Rectangle rectangle = new Rectangle(3, 2, 7, 5);
canvas.Shapes.Add(rectangle);
canvas.Draw();
BucketFill bucketFillOutsideRectangle = new BucketFill(10, 4, "c");
string[] actual = bucketFillOutsideRectangle.Draw(canvas);
CollectionAssert.AreEqual(expected, actual);
}
void Start()
{
bucketFill = GameObject.Find("Bucket Fill").GetComponent <BucketFill>();
colorChanger = GameObject.Find("Selector").GetComponent <ColorChanger>();
materialHistory = new List <Material>();
materialHistory.Add(GetComponent <Renderer>().material);
}
public void ShouldSkipTheAlien()
{
var mock = new Mock <ICanvas>();
mock.SetupGet(canvas => canvas.Width).Returns(2);
mock.SetupGet(canvas => canvas.Height).Returns(2);
IPixel [,] map = Prepare2x2Map();
map[1, 1].Color = 3; // cell [1,1] is in different color
mock.Setup(canvas => canvas.GetPixel(0, 0)).Returns(map[0, 0]);
mock.Setup(canvas => canvas.GetPixel(0, 1)).Returns(map[0, 1]);
mock.Setup(canvas => canvas.GetPixel(1, 0)).Returns(map[1, 0]);
mock.Setup(canvas => canvas.GetPixel(1, 1)).Returns(map[1, 1]);
mock.Setup(canvas => canvas.Draw(0, 0, 1)).Callback(() => map[0, 0].Color = 1);
mock.Setup(canvas => canvas.Draw(0, 1, 1)).Callback(() => map[0, 1].Color = 1);
mock.Setup(canvas => canvas.Draw(1, 0, 1)).Callback(() => map[1, 0].Color = 1);
mock.Setup(canvas => canvas.Draw(1, 1, 1)).Callback(() => map[1, 1].Color = 1);
BucketFill fill = new BucketFill(mock.Object, 0, 0, 1);
fill.Execute();
mock.Verify(canvas => canvas.Draw(0, 0, 1), Times.Once());
mock.Verify(canvas => canvas.Draw(0, 1, 1), Times.Once());
mock.Verify(canvas => canvas.Draw(1, 0, 1), Times.Once());
mock.Verify(canvas => canvas.Draw(1, 1, 1), Times.Never()); // cell [1,1] is in different color
Assert.Equal(1, map[0, 0].Color);
Assert.Equal(1, map[0, 1].Color);
Assert.Equal(1, map[1, 0].Color);
Assert.Equal(3, map[1, 1].Color); // cell [1,1] is in different color
}
string ProcessCommands(string input)
{
string output = "";
try
{
var allowedCommands = new string[] { "C", "L", "R", "B", "FILE" };
string[] commands = input.Trim().Split(' ');
string elementComand = commands.Length > 0 ? commands[0].ToUpper() : " ";
if (allowedCommands.Contains(elementComand))
{
if (elementComand == "C")
{
workingCanvas = new Canvas(int.Parse(commands[1]), int.Parse(commands[2]));
}
else if (workingCanvas != null)
{
switch (elementComand)
{
case "L":
Line line = new Line(int.Parse(commands[1]), int.Parse(commands[2]), int.Parse(commands[3]), int.Parse(commands[4]));
workingCanvas.Elements.Add(line);
break;
case "R":
Rectangle rectangle = new Rectangle(int.Parse(commands[1]), int.Parse(commands[2]), int.Parse(commands[3]), int.Parse(commands[4]));
workingCanvas.Elements.Add(rectangle);
break;
case "B":
BucketFill bucket = new BucketFill(int.Parse(commands[1]), int.Parse(commands[2]), commands[3]);
workingCanvas.Elements.Add(bucket);
break;
}
}
else
{
output = string.Concat("Sorry, you need to create a canvas first. <br/>");
}
if (workingCanvas != null)
{
output = workingCanvas.Draw("<br/>");
}
}
else
{
output = string.Concat("Sorry, command: ", elementComand, " is not allowed. <br/>");
}
}
catch (Exception ex)
{
output = string.Concat("Sorry, something is wrong with the command input. <br/>");
}
return(output);
}
static void ProcessCommands(string input)
{
try
{
var allowedCommands = new string[] { "C", "L", "R", "B", "FILE" };
string[] commands = input.Trim().Split(' ');
string elementComand = commands.Length > 0 ? commands[0].ToUpper() : " ";
if (allowedCommands.Contains(elementComand))
{
if (elementComand == "FILE")
{
ProcessFromFile(commands[1]);
}
else if (elementComand == "C")
{
workingCanvas = new Canvas(int.Parse(commands[1]), int.Parse(commands[2]));
}
else if (workingCanvas != null)
{
switch (elementComand)
{
case "L":
Line line = new Line(int.Parse(commands[1]), int.Parse(commands[2]), int.Parse(commands[3]), int.Parse(commands[4]));
workingCanvas.Elements.Add(line);
break;
case "R":
Rectangle rectangle = new Rectangle(int.Parse(commands[1]), int.Parse(commands[2]), int.Parse(commands[3]), int.Parse(commands[4]));
workingCanvas.Elements.Add(rectangle);
break;
case "B":
BucketFill bucket = new BucketFill(int.Parse(commands[1]), int.Parse(commands[2]), commands[3]);
workingCanvas.Elements.Add(bucket);
break;
}
}
else
{
WriteErrorLine(string.Concat("Sorry, you need to create a canvas first, enter ? for help."));
}
if (workingCanvas != null && elementComand != "FILE")
{
WriteResultLine(workingCanvas.Draw(Environment.NewLine));
}
}
else
{
WriteErrorLine(string.Concat("Sorry, command: ", elementComand, " is not allowed, enter ? for help."));
}
}
catch (Exception ex)
{
WriteErrorLine(string.Concat("Sorry, something is wrong with the command input, enter ? for help."));
}
}
public void ShouldFillPropertiesFromConstructor()
{
BucketFill bucket = new BucketFill(1, 2, "+");
Assert.IsNotNull(bucket.Properties);
Assert.AreEqual(bucket.Properties.X1, 1);
Assert.AreEqual(bucket.Properties.Y1, 2);
Assert.AreEqual("+", bucket.Properties.BrushChar);
}
string ProcessCommands(string input)
{
string output = "";
try
{
var allowedCommands = new string[] { "C", "L", "R", "B", "FILE" };
string[] commands = input.Trim().Split(' ');
string elementComand = commands.Length > 0 ? commands[0].ToUpper() : " ";
if (allowedCommands.Contains(elementComand))
{
if (elementComand == "C")
{
workingCanvas = new Canvas(int.Parse(commands[1]), int.Parse(commands[2]));
}
else if (workingCanvas != null)
{
switch (elementComand)
{
case "L":
Line line = new Line(int.Parse(commands[1]), int.Parse(commands[2]), int.Parse(commands[3]), int.Parse(commands[4]));
workingCanvas.Elements.Add(line);
break;
case "R":
Rectangle rectangle = new Rectangle(int.Parse(commands[1]), int.Parse(commands[2]), int.Parse(commands[3]), int.Parse(commands[4]));
workingCanvas.Elements.Add(rectangle);
break;
case "B":
BucketFill bucket = new BucketFill(int.Parse(commands[1]), int.Parse(commands[2]), commands[3]);
workingCanvas.Elements.Add(bucket);
break;
}
}
else
{
output = string.Concat("Sorry, you need to create a canvas first. <br/>");
}
if (workingCanvas != null)
{
output = workingCanvas.Draw("<br/>");
}
}
else
{
output = string.Concat("Sorry, command: ", elementComand, " is not allowed. <br/>");
}
}
catch (Exception ex)
{
output = string.Concat("Sorry, something is wrong with the command input. <br/>");
}
return output;
}
public void DrawBucketFill_OutsideCanvas_ThrowsDrawException()
{
Canvas canvas = new Canvas(20, 5);
canvas.Draw();
BucketFill bucketFillOutsideRectangle = new BucketFill(30, 2, "c");
Action actual = () => bucketFillOutsideRectangle.Draw(canvas);
Exception ex = Assert.ThrowsException <DrawingException>(actual);
Assert.AreEqual(ExceptionMessages.SHAPE_MUST_BE_DRAWN_INSIDE_CANVAS, ex.Message);
}
public string[] GetDrawingProgramAnswerForUserCommand(UserCommand userCommand, ref Canvas canvas)
{
if (userCommand == null)
{
throw new ArgumentException(ExceptionMessages.COMMAND_CANNOT_BE_NULL);
}
if (userCommand.IsCanvasNeededToContinue && canvas == null)
{
throw new ShapeException(ExceptionMessages.CREATE_CANVAS_FIRST);
}
switch (userCommand.Command)
{
case EnumCommand.C:
canvas = new Canvas(userCommand.FirstArgument, userCommand.SecondArgument);
break;
case EnumCommand.L:
Line line = new Line(userCommand.FirstCoordinate, userCommand.SecondCoordinate);
canvas.Shapes.Add(line);
break;
case EnumCommand.R:
Rectangle rectangle = new Rectangle(userCommand.FirstCoordinate, userCommand.SecondCoordinate);
canvas.Shapes.Add(rectangle);
break;
case EnumCommand.B:
BucketFill bucketFill = new BucketFill(userCommand.FirstCoordinate, userCommand.ThirdArgument);
canvas.Shapes.Add(bucketFill);
break;
case EnumCommand.Q:
break;
case EnumCommand.HELP:
return(CLIMessages.DOCUMENTATION);
case EnumCommand.NOT_RECOGNIZED:
default:
return(new string[] { CLIMessages.NOT_RECOGNIZED_COMMAND });
}
if (userCommand.IsCanvasCommand)
{
return(canvas.Draw());
}
return(new string[0]);
}
public void DrawBucketFill_OnAlreadyExistentLine_ThrowsDrawException()
{
Canvas canvas = new Canvas(20, 5);
Line line = new Line(2, 2, 5, 2);
canvas.Shapes.Add(line);
canvas.Draw();
BucketFill bucketFillOutsideRectangle = new BucketFill(3, 2, "c");
Action actual = () => bucketFillOutsideRectangle.Draw(canvas);
Exception ex = Assert.ThrowsException <DrawingException>(actual);
Assert.AreEqual(ExceptionMessages.BUCKET_FILL_MUST_BE_CREATED_ON_EMPTY_POINT, ex.Message);
}
public void DrawBucketFill_EmptyCanvas_CanvasFilled()
{
string[] expected = new string[]
{
"----------------------",
"|cccccccccccccccccccc|",
"|cccccccccccccccccccc|",
"|cccccccccccccccccccc|",
"|cccccccccccccccccccc|",
"----------------------"
};
Canvas canvas = new Canvas(20, 4);
canvas.Draw();
BucketFill bucketFillAllCanvas = new BucketFill(10, 2, "c");
string[] actual = bucketFillAllCanvas.Draw(canvas);
CollectionAssert.AreEqual(expected, actual);
}
public void FillTheCancas()
{
var mock = new Mock <ICanvas>();
mock.SetupGet(canvas => canvas.Width).Returns(2);
mock.SetupGet(canvas => canvas.Height).Returns(2);
IPixel [,] map = Prepare2x2Map();
mock.Setup(canvas => canvas.GetPixel(0, 0)).Returns(map[0, 0]);
mock.Setup(canvas => canvas.GetPixel(0, 1)).Returns(map[0, 1]);
mock.Setup(canvas => canvas.GetPixel(1, 0)).Returns(map[1, 0]);
mock.Setup(canvas => canvas.GetPixel(1, 1)).Returns(map[1, 1]);
mock.Setup(canvas => canvas.Draw(0, 0, 1)).Callback(() => map[0, 0].Color = 1);
mock.Setup(canvas => canvas.Draw(0, 1, 1)).Callback(() => map[0, 1].Color = 1);
mock.Setup(canvas => canvas.Draw(1, 0, 1)).Callback(() => map[1, 0].Color = 1);
mock.Setup(canvas => canvas.Draw(1, 1, 1)).Callback(() => map[1, 1].Color = 1);
BucketFill fill = new BucketFill(mock.Object, 0, 0, 1);
fill.Execute();
mock.Verify(canvas => canvas.Draw(0, 0, 1), Times.Once());
mock.Verify(canvas => canvas.Draw(0, 1, 1), Times.Once());
mock.Verify(canvas => canvas.Draw(1, 0, 1), Times.Once());
mock.Verify(canvas => canvas.Draw(1, 1, 1), Times.Once());
Assert.Equal(1, map[0, 0].Color);
Assert.Equal(1, map[0, 1].Color);
Assert.Equal(1, map[1, 0].Color);
Assert.Equal(1, map[1, 1].Color);
}
public void DrawBucketFill_LeftOnCanvasWithVerticalLine_LeftSideCanvasFilled()
{
string[] expected = new string[]
{
"----------------------",
"|cccccccccx |",
"|cccccccccx |",
"|cccccccccx |",
"|cccccccccx |",
"----------------------"
};
Canvas canvas = new Canvas(20, 4);
Line verticalLine = new Line(10, 1, 10, 4);
canvas.Shapes.Add(verticalLine);
canvas.Draw();
BucketFill bucketFillLeftSide = new BucketFill(5, 3, "c");
string[] actual = bucketFillLeftSide.Draw(canvas);
CollectionAssert.AreEqual(expected, actual);
}
public void ShouldHaveADefaultBrush()
{
BucketFill bucket = new BucketFill(1, 2);
Assert.AreEqual("o", bucket.Properties.BrushChar);
}
