|
|
|
|
|
|
55
|
@Ignore("Remove to run test")
|
55
|
@Ignore("Remove to run test")
|
|
56
|
@Test
|
56
|
@Test
|
|
57
|
public void testQueensCannotAttack() {
|
57
|
public void testQueensCannotAttack() {
|
|
58
|
- final QueenAttackCalculator calculator
|
|
|
|
|
|
58
|
+ QueenAttackCalculator calculator
|
|
59
|
= new QueenAttackCalculator(new Queen(2, 4), new Queen(6, 6));
|
59
|
= new QueenAttackCalculator(new Queen(2, 4), new Queen(6, 6));
|
|
60
|
|
60
|
|
|
61
|
assertFalse(calculator.canQueensAttackOneAnother());
|
61
|
assertFalse(calculator.canQueensAttackOneAnother());
|
|
|
|
|
|
|
64
|
@Ignore("Remove to run test")
|
64
|
@Ignore("Remove to run test")
|
|
65
|
@Test
|
65
|
@Test
|
|
66
|
public void testQueensCanAttackOnTheSameRow() {
|
66
|
public void testQueensCanAttackOnTheSameRow() {
|
|
67
|
- final QueenAttackCalculator calculator
|
|
|
|
|
|
67
|
+ QueenAttackCalculator calculator
|
|
68
|
= new QueenAttackCalculator(new Queen(2, 4), new Queen(2, 6));
|
68
|
= new QueenAttackCalculator(new Queen(2, 4), new Queen(2, 6));
|
|
69
|
|
69
|
|
|
70
|
assertTrue(calculator.canQueensAttackOneAnother());
|
70
|
assertTrue(calculator.canQueensAttackOneAnother());
|
|
|
|
|
|
|
73
|
@Ignore("Remove to run test")
|
73
|
@Ignore("Remove to run test")
|
|
74
|
@Test
|
74
|
@Test
|
|
75
|
public void testQueensCanAttackOnTheSameColumn() {
|
75
|
public void testQueensCanAttackOnTheSameColumn() {
|
|
76
|
- final QueenAttackCalculator calculator
|
|
|
|
|
|
76
|
+ QueenAttackCalculator calculator
|
|
77
|
= new QueenAttackCalculator(new Queen(4, 5), new Queen(2, 5));
|
77
|
= new QueenAttackCalculator(new Queen(4, 5), new Queen(2, 5));
|
|
78
|
|
78
|
|
|
79
|
assertTrue(calculator.canQueensAttackOneAnother());
|
79
|
assertTrue(calculator.canQueensAttackOneAnother());
|
|
|
|
|
|
|
82
|
@Ignore("Remove to run test")
|
82
|
@Ignore("Remove to run test")
|
|
83
|
@Test
|
83
|
@Test
|
|
84
|
public void testQueensCanAttackOnFirstDiagonal() {
|
84
|
public void testQueensCanAttackOnFirstDiagonal() {
|
|
85
|
- final QueenAttackCalculator calculator
|
|
|
|
|
|
85
|
+ QueenAttackCalculator calculator
|
|
86
|
= new QueenAttackCalculator(new Queen(2, 2), new Queen(0, 4));
|
86
|
= new QueenAttackCalculator(new Queen(2, 2), new Queen(0, 4));
|
|
87
|
|
87
|
|
|
88
|
assertTrue(calculator.canQueensAttackOneAnother());
|
88
|
assertTrue(calculator.canQueensAttackOneAnother());
|
|
|
|
|
|
|
91
|
@Ignore("Remove to run test")
|
91
|
@Ignore("Remove to run test")
|
|
92
|
@Test
|
92
|
@Test
|
|
93
|
public void testQueensCanAttackOnSecondDiagonal() {
|
93
|
public void testQueensCanAttackOnSecondDiagonal() {
|
|
94
|
- final QueenAttackCalculator calculator
|
|
|
|
|
|
94
|
+ QueenAttackCalculator calculator
|
|
95
|
= new QueenAttackCalculator(new Queen(2, 2), new Queen(3, 1));
|
95
|
= new QueenAttackCalculator(new Queen(2, 2), new Queen(3, 1));
|
|
96
|
|
96
|
|
|
97
|
assertTrue(calculator.canQueensAttackOneAnother());
|
97
|
assertTrue(calculator.canQueensAttackOneAnother());
|
|
|
|
|
|
|
100
|
@Ignore("Remove to run test")
|
100
|
@Ignore("Remove to run test")
|
|
101
|
@Test
|
101
|
@Test
|
|
102
|
public void testQueensCanAttackOnThirdDiagonal() {
|
102
|
public void testQueensCanAttackOnThirdDiagonal() {
|
|
103
|
- final QueenAttackCalculator calculator
|
|
|
|
|
|
103
|
+ QueenAttackCalculator calculator
|
|
104
|
= new QueenAttackCalculator(new Queen(2, 2), new Queen(1, 1));
|
104
|
= new QueenAttackCalculator(new Queen(2, 2), new Queen(1, 1));
|
|
105
|
|
105
|
|
|
106
|
assertTrue(calculator.canQueensAttackOneAnother());
|
106
|
assertTrue(calculator.canQueensAttackOneAnother());
|
|
|
|
|
|
|
109
|
@Ignore("Remove to run test")
|
109
|
@Ignore("Remove to run test")
|
|
110
|
@Test
|
110
|
@Test
|
|
111
|
public void testQueensCanAttackOnFourthDiagonal() {
|
111
|
public void testQueensCanAttackOnFourthDiagonal() {
|
|
112
|
- final QueenAttackCalculator calculator
|
|
|
|
|
|
112
|
+ QueenAttackCalculator calculator
|
|
113
|
= new QueenAttackCalculator(new Queen(2, 2), new Queen(5, 5));
|
113
|
= new QueenAttackCalculator(new Queen(2, 2), new Queen(5, 5));
|
|
114
|
|
114
|
|
|
115
|
assertTrue(calculator.canQueensAttackOneAnother());
|
115
|
assertTrue(calculator.canQueensAttackOneAnother());
|