Skip to content

Commit d14e62a

Browse files
jpreesejpreese
committed
Implement Queen Attack generator
1 parent 5605560 commit d14e62a

4 files changed

Lines changed: 157 additions & 21 deletions

File tree

‎exercises/queen-attack/Example.cs‎

Lines changed: 19 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ public Queen(int row, int column)
1212
public int Column { get; }
1313
}
1414

15-
public static class Queens
15+
public static class QueenAttack
1616
{
1717
public static bool CanAttack(Queen white, Queen black)
1818
{
@@ -25,4 +25,22 @@ public static bool CanAttack(Queen white, Queen black)
2525
black.Column == white.Column ||
2626
Math.Abs(black.Row - white.Row) == Math.Abs(black.Column - white.Column);
2727
}
28+
29+
public static bool Create(int row, int column)
30+
{
31+
const int MIN_VALUE = 0;
32+
const int MAX_VALUE = 7;
33+
34+
if (row < MIN_VALUE || column < MIN_VALUE)
35+
{
36+
return false;
37+
}
38+
39+
if (row > MAX_VALUE || column > MAX_VALUE)
40+
{
41+
return false;
42+
}
43+
44+
return true;
45+
}
2846
}

‎exercises/queen-attack/QueenAttack.cs‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,10 +12,15 @@ public Queen(int row, int column)
1212
public int Column { get; }
1313
}
1414

15-
public static class Queens
15+
public static class QueenAttack
1616
{
1717
public static bool CanAttack(Queen white, Queen black)
1818
{
1919
throw new NotImplementedException("You need to implement this function.");
2020
}
21+
22+
public static bool Create(int row, int column)
23+
{
24+
throw new NotImplementedException("You need to implement this function.");
25+
}
2126
}

‎exercises/queen-attack/QueenAttackTest.cs‎

Lines changed: 56 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,55 +1,92 @@
1-
using System;
1+
// This file was auto-generated based on version 1.0.0 of the canonical data.
2+
23
using Xunit;
34

45
public class QueenAttackTest
56
{
67
[Fact]
7-
public void Cannot_occupy_same_space()
8+
public void Queen_with_a_valid_position()
9+
{
10+
Assert.True(QueenAttack.Create(2, 2));
11+
}
12+
13+
[Fact(Skip = "Remove to run test")]
14+
public void Queen_must_have_positive_rank()
15+
{
16+
Assert.False(QueenAttack.Create(-2, 2));
17+
}
18+
19+
[Fact(Skip = "Remove to run test")]
20+
public void Queen_must_have_rank_on_board()
21+
{
22+
Assert.False(QueenAttack.Create(8, 4));
23+
}
24+
25+
[Fact(Skip = "Remove to run test")]
26+
public void Queen_must_have_positive_file()
27+
{
28+
Assert.False(QueenAttack.Create(2, -2));
29+
}
30+
31+
[Fact(Skip = "Remove to run test")]
32+
public void Queen_must_have_file_on_board()
833
{
9-
var white = new Queen(2, 4);
10-
var black = new Queen(2, 4);
11-
Assert.Throws<ArgumentException>(() => Queens.CanAttack(white, black));
34+
Assert.False(QueenAttack.Create(4, 8));
1235
}
1336

1437
[Fact(Skip = "Remove to run test")]
15-
public void Cannot_attack()
38+
public void Can_not_attack()
1639
{
17-
Assert.False(Queens.CanAttack(new Queen(2, 3), new Queen(4, 7)));
40+
var whiteQueen = new Queen(2,4);
41+
var blackQueen = new Queen(6,6);
42+
Assert.False(QueenAttack.CanAttack(whiteQueen, blackQueen));
1843
}
1944

2045
[Fact(Skip = "Remove to run test")]
21-
public void Can_attack_on_same_row()
46+
public void Can_attack_on_same_rank()
2247
{
23-
Assert.True(Queens.CanAttack(new Queen(2, 4), new Queen(2, 7)));
48+
var whiteQueen = new Queen(2,4);
49+
var blackQueen = new Queen(2,6);
50+
Assert.True(QueenAttack.CanAttack(whiteQueen, blackQueen));
2451
}
2552

2653
[Fact(Skip = "Remove to run test")]
27-
public void Can_attack_on_same_column()
54+
public void Can_attack_on_same_file()
2855
{
29-
Assert.True(Queens.CanAttack(new Queen(5, 4), new Queen(2, 4)));
56+
var whiteQueen = new Queen(4,5);
57+
var blackQueen = new Queen(2,5);
58+
Assert.True(QueenAttack.CanAttack(whiteQueen, blackQueen));
3059
}
3160

3261
[Fact(Skip = "Remove to run test")]
33-
public void Can_attack_on_diagonal()
62+
public void Can_attack_on_first_diagonal()
3463
{
35-
Assert.True(Queens.CanAttack(new Queen(1, 1), new Queen(6, 6)));
64+
var whiteQueen = new Queen(2,2);
65+
var blackQueen = new Queen(0,4);
66+
Assert.True(QueenAttack.CanAttack(whiteQueen, blackQueen));
3667
}
3768

3869
[Fact(Skip = "Remove to run test")]
39-
public void Can_attack_on_other_diagonal()
70+
public void Can_attack_on_second_diagonal()
4071
{
41-
Assert.True(Queens.CanAttack(new Queen(0, 6), new Queen(1, 7)));
72+
var whiteQueen = new Queen(2,2);
73+
var blackQueen = new Queen(3,1);
74+
Assert.True(QueenAttack.CanAttack(whiteQueen, blackQueen));
4275
}
4376

4477
[Fact(Skip = "Remove to run test")]
45-
public void Can_attack_on_yet_another_diagonal()
78+
public void Can_attack_on_third_diagonal()
4679
{
47-
Assert.True(Queens.CanAttack(new Queen(4, 1), new Queen(6, 3)));
80+
var whiteQueen = new Queen(2,2);
81+
var blackQueen = new Queen(1,1);
82+
Assert.True(QueenAttack.CanAttack(whiteQueen, blackQueen));
4883
}
4984

5085
[Fact(Skip = "Remove to run test")]
51-
public void Can_attack_on_a_diagonal_slanted_the_other_way()
86+
public void Can_attack_on_fourth_diagonal()
5287
{
53-
Assert.True(Queens.CanAttack(new Queen(6, 1), new Queen(1, 6)));
88+
var whiteQueen = new Queen(2,2);
89+
var blackQueen = new Queen(5,5);
90+
Assert.True(QueenAttack.CanAttack(whiteQueen, blackQueen));
5491
}
5592
}

‎generators/Exercises/QueenAttack.cs‎

Lines changed: 76 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
using Generators.Input;
2+
using Generators.Output;
3+
using Newtonsoft.Json.Linq;
4+
using System;
5+
using System.Collections.Generic;
6+
7+
namespace Generators.Exercises
8+
{
9+
public class QueenAttack : Exercise
10+
{
11+
protected override void UpdateCanonicalData(CanonicalData canonicalData)
12+
{
13+
foreach(var canonicalDataCase in canonicalData.Cases)
14+
{
15+
if(canonicalDataCase.Property == "create")
16+
{
17+
SetCreatePropertyData(canonicalDataCase);
18+
}
19+
}
20+
}
21+
22+
protected override string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
23+
{
24+
if (testMethodBody.CanonicalDataCase.Property == "canAttack")
25+
{
26+
return RenderCanAttackAssert(testMethodBody);
27+
}
28+
29+
return base.RenderTestMethodBodyAssert(testMethodBody);
30+
}
31+
32+
private static string RenderCanAttackAssert(TestMethodBody testMethodBody)
33+
{
34+
const string template =
35+
@"var whiteQueen = new Queen({{whiteQueenX}},{{whiteQueenY}});
36+
var blackQueen = new Queen({{blackQueenX}},{{blackQueenY}});
37+
Assert.{% if Expected %}True{% else %}False{% endif %}(QueenAttack.CanAttack(whiteQueen, blackQueen));";
38+
39+
var whiteQueenPositions = GetCoordinatesFromPosition(testMethodBody.CanonicalDataCase.Input["white_queen"]);
40+
var blackQueenPositions = GetCoordinatesFromPosition(testMethodBody.CanonicalDataCase.Input["black_queen"]);
41+
42+
var templateParameters = new
43+
{
44+
whiteQueenX = whiteQueenPositions.Item1,
45+
whiteQueenY = whiteQueenPositions.Item2,
46+
blackQueenX = blackQueenPositions.Item1,
47+
blackQueenY = blackQueenPositions.Item2,
48+
Expected = testMethodBody.CanonicalDataCase.Expected
49+
};
50+
51+
return TemplateRenderer.RenderInline(template, templateParameters);
52+
}
53+
54+
private static Tuple<int, int> GetCoordinatesFromPosition(object rawPosition)
55+
{
56+
var coordinates = ((JObject)rawPosition).ToObject<Dictionary<string, string>>()["position"].Split(',');
57+
58+
var positionX = int.Parse(coordinates[0].TrimStart('('));
59+
var positionY = int.Parse(coordinates[1].TrimEnd(')'));
60+
61+
return Tuple.Create(positionX, positionY);
62+
}
63+
64+
private static void SetCreatePropertyData(CanonicalDataCase canonicalDataCase)
65+
{
66+
canonicalDataCase.Expected = (long)canonicalDataCase.Expected >= 0 ? true : false;
67+
68+
var coordinates = GetCoordinatesFromPosition(canonicalDataCase.Input["queen"]);
69+
canonicalDataCase.Input = new Dictionary<string, object>
70+
{
71+
["X"] = coordinates.Item1,
72+
["Y"] = coordinates.Item2
73+
};
74+
}
75+
}
76+
}

0 commit comments

Comments
 (0)