unit_tests/TestChessBoard/testchessboard.cpp

   1 // system includes
   2 #include <QObject>
   3 #include <QtTest/QtTest>
   4 #include <iostream>
   5 #include <string>
   6 #include <vector>
   7
   8 // classes to be tested
   9 #include "../../src/logic/board.h"
  10 #include "../../src/logic/colour.h"
  11 #include "../../src/logic/chessboard.h"
  12 #include "../../src/logic/square.h"
  13 #include "../../src/logic/chesspieces-meta.h"
  14
  15 class TestChessBoard : public QObject
  16 {
  17     Q_OBJECT
  18
  19 private slots:
  20     // Test case declarations
  21     void createBoard_data();
  22     void createBoard();
  23     void checkUnits_data();
  24     void checkUnits();
  25     void getPosition_data();
  26     void getPosition();
  27     void getCoordinates_data();
  28     void getCoordinates();
  29 };
  30
  31 // Use Q_DECLARE_METATYPE in order to use 'custom' types in _data() functions.
  32 Q_DECLARE_METATYPE(std::string)
  33 Q_DECLARE_METATYPE(Colour)
  34
  35 // Test case implementations
  36 void TestChessBoard::createBoard_data()
  37 {
  38     QTest::addColumn<std::size_t>("expected");
  39     QTest::addColumn<std::size_t>("black_start");
  40     QTest::addColumn<std::size_t>("black_end");
  41     QTest::addColumn<std::size_t>("white_start");
  42     QTest::addColumn<std::size_t>("white_end");
  43
  44     QTest::newRow("8x8 board") << std::size_t(64) << std::size_t(0)
  45         << std::size_t(16) << std::size_t(48) << std::size_t(64);
  46 }
  47
  48 void TestChessBoard::createBoard()
  49 {
  50     QFETCH(std::size_t, expected);
  51     QFETCH(std::size_t, black_start);
  52     QFETCH(std::size_t, black_end);
  53     QFETCH(std::size_t, white_start);
  54     QFETCH(std::size_t, white_end);
  55
  56     std::vector<Square> squares = ChessBoard::createBoard();
  57     QCOMPARE(squares.size(), expected);
  58
  59     // black units
  60     for (std::size_t i = black_start; i < black_end; ++i)
  61     {
  62         QVERIFY(squares.at(i).hasPiece());
  63     }
  64
  65     // empty squares
  66     for (std::size_t i = black_end; i < white_start; ++i)
  67     {
  68         QVERIFY(!squares.at(i).hasPiece());
  69     }
  70
  71     // white units
  72     for (std::size_t i = white_start; i < white_end; ++i)
  73     {
  74         QVERIFY(squares.at(i).hasPiece());
  75     }
  76 }
  77
  78 void TestChessBoard::checkUnits_data()
  79 {
  80     Colour white = WHITE;
  81     Colour black = BLACK;
  82     Colour undefined = UNDEFINED;
  83     std::string empty("");
  84     std::string pawn("Pawn");
  85     std::string rook("Rook");
  86     std::string knight("Knight");
  87     std::string bishop("Bishop");
  88     std::string queen("Queen");
  89     std::string king("King");
  90
  91     QTest::addColumn<std::size_t>("position");
  92     QTest::addColumn<Colour>("colour");
  93     QTest::addColumn<std::string>("unit");
  94
  95     QTest::newRow("black rook at a8")   << std::size_t(0)  << black << rook;
  96     QTest::newRow("black knight at b8") << std::size_t(1)  << black << knight;
  97     QTest::newRow("black bishop at c8") << std::size_t(2)  << black << bishop;
  98     QTest::newRow("black queen at d1")  << std::size_t(3)  << black << queen;
  99     QTest::newRow("black king at e1")   << std::size_t(4)  << black << king;
 100     QTest::newRow("black bishop at f8") << std::size_t(5)  << black << bishop;
 101     QTest::newRow("black knight at g8") << std::size_t(6)  << black << knight;
 102     QTest::newRow("black rook at h8")   << std::size_t(7)  << black << rook;
 103
 104     QTest::newRow("black pawn at a7")   << std::size_t(8)  << black << pawn;
 105     QTest::newRow("black pawn at b7")   << std::size_t(9)  << black << pawn;
 106     QTest::newRow("black pawn at c7")   << std::size_t(10) << black << pawn;
 107     QTest::newRow("black pawn at d7")   << std::size_t(11) << black << pawn;
 108     QTest::newRow("black pawn at e7")   << std::size_t(12) << black << pawn;
 109     QTest::newRow("black pawn at f7")   << std::size_t(13) << black << pawn;
 110     QTest::newRow("black pawn at g7")   << std::size_t(14) << black << pawn;
 111     QTest::newRow("black pawn at h7")   << std::size_t(15) << black << pawn;
 112
 113     // All the empty squares needs to be tested as well
 114     for (std::size_t i = 16; i < 48; ++i)
 115     {
 116         QTest::newRow("empty slots") << i << undefined << empty;
 117     }
 118
 119     QTest::newRow("white pawn at a2")   << std::size_t(48) << white << pawn;
 120     QTest::newRow("white pawn at b2")   << std::size_t(49) << white << pawn;
 121     QTest::newRow("white pawn at c2")   << std::size_t(50) << white << pawn;
 122     QTest::newRow("white pawn at d2")   << std::size_t(51) << white << pawn;
 123     QTest::newRow("white pawn at e2")   << std::size_t(52) << white << pawn;
 124     QTest::newRow("white pawn at f2")   << std::size_t(53) << white << pawn;
 125     QTest::newRow("white pawn at g2")   << std::size_t(54) << white << pawn;
 126     QTest::newRow("white pawn at h2")   << std::size_t(55) << white << pawn;
 127
 128     QTest::newRow("white rook at a1")   << std::size_t(56) << white << rook;
 129     QTest::newRow("white knight at b1") << std::size_t(57) << white << knight;
 130     QTest::newRow("white bishop at c1") << std::size_t(58) << white << bishop;
 131     QTest::newRow("white queen at d1")  << std::size_t(59) << white << queen;
 132     QTest::newRow("white king at e1")   << std::size_t(60) << white << king;
 133     QTest::newRow("white bishop at f1") << std::size_t(61) << white << bishop;
 134     QTest::newRow("white knight at g1") << std::size_t(62) << white << knight;
 135     QTest::newRow("white rook at h1")   << std::size_t(63) << white << rook;
 136 }
 137
 138 void TestChessBoard::checkUnits()
 139 {
 140     QFETCH(std::size_t, position);
 141     QFETCH(Colour, colour);
 142     QFETCH(std::string, unit);
 143
 144     std::vector<Square> squares = ChessBoard::createBoard();
 145     QCOMPARE(squares.size(), std::size_t(64));
 146
 147     QVERIFY( position < std::size_t(64) );
 148     Square& shouldHaveUnit = squares.at(position);
 149
 150     QCOMPARE(shouldHaveUnit.getNameOfPiece(), unit);
 151     QCOMPARE(shouldHaveUnit.getColourOfPiece(), colour);
 152 }
 153
 154 void TestChessBoard::getCoordinates_data()
 155 {
 156     QTest::addColumn<std::size_t>("position");
 157     QTest::addColumn<std::size_t>("column");
 158     QTest::addColumn<std::size_t>("row");
 159     QTest::addColumn<bool>("valid");
 160
 161     QTest::newRow("with position index 0, coordinates should be (0, 0)")
 162         << std::size_t(0) << std::size_t(0) << std::size_t(0) << true;
 163
 164     QTest::newRow("with position index 7, coordinates should be (7, 0)")
 165         << std::size_t(7) << std::size_t(7) << std::size_t(0) << true;
 166
 167     QTest::newRow("with position index 63, coordinates should be (7, 7)")
 168         << std::size_t(63) << std::size_t(7) << std::size_t(7) << true;
 169
 170     QTest::newRow("with position index 56, coordinates should be (0, 7)")
 171         << std::size_t(56) << std::size_t(0) << std::size_t(7) << true;
 172
 173     QTest::newRow("with position index 49, coordinates should be (1, 6)")
 174         << std::size_t(49) << std::size_t(1) << std::size_t(6) << true;
 175
 176     QTest::newRow("with position index 29, coordinates should be (5, 3)")
 177         << std::size_t(29) << std::size_t(5) << std::size_t(3) << true;
 178
 179     QTest::newRow("with position index 18, coordinates should be (2, 2)")
 180         << std::size_t(18) << std::size_t(2) << std::size_t(2) << true;
 181
 182     QTest::newRow("with position index 52, coordinates should be (4, 6)")
 183         << std::size_t(52) << std::size_t(4) << std::size_t(6) << true;
 184
 185     QTest::newRow("with position index 47, coordinates should be (7, 5)")
 186         << std::size_t(47) << std::size_t(7) << std::size_t(5) << true;
 187
 188     QTest::newRow("with position index 12, coordinates should be (4, 1)")
 189         << std::size_t(12) << std::size_t(4) << std::size_t(1) << true;
 190
 191     QTest::newRow("with position index 57, coordinates should be (1, 7)")
 192         << std::size_t(57) << std::size_t(1) << std::size_t(7) << true;
 193
 194     QTest::newRow("with position index 64, coordinates should be (0, 0)")
 195         << std::size_t(64) << std::size_t(-1) << std::size_t(-1) << false;
 196 }
 197
 198 void TestChessBoard::getCoordinates()
 199 {
 200     QFETCH(std::size_t, position);
 201     QFETCH(std::size_t, column);
 202     QFETCH(std::size_t, row);
 203     QFETCH(bool, valid);
 204
 205     std::size_t x = 0, y = 0;
 206     bool ret = ChessBoard::getCoordinates(position, x, y);
 207
 208     QCOMPARE(ret, valid);
 209     QCOMPARE(x, column);
 210     QCOMPARE(y, row);
 211 }
 212
 213 void TestChessBoard::getPosition_data()
 214 {
 215     QTest::addColumn<std::size_t>("column");
 216     QTest::addColumn<std::size_t>("row");
 217     QTest::addColumn<std::size_t>("expected");
 218
 219     QTest::newRow("coordinates (0, 0) should be same as 0 index")
 220         << std::size_t(0) << std::size_t(0) << std::size_t(0);
 221
 222     QTest::newRow("coordinates (0, 7) should be same as 56 index")
 223         << std::size_t(0) << std::size_t(7) << std::size_t(56);
 224
 225     QTest::newRow("coordinates (7, 0) should be same as 7 index")
 226         << std::size_t(7) << std::size_t(0) << std::size_t(7);
 227
 228     QTest::newRow("coordinates (7, 7) should be same as 63 index")
 229         << std::size_t(7) << std::size_t(7) << std::size_t(63);
 230
 231     QTest::newRow("coordinates (4, 5) should be same as 44 index")
 232         << std::size_t(4) << std::size_t(5) << std::size_t(44);
 233
 234     QTest::newRow("coordinates (1, 4) should be same as 33 index")
 235         << std::size_t(1) << std::size_t(4) << std::size_t(33);
 236
 237     QTest::newRow("coordinates (2, 6) should be same as 50 index")
 238         << std::size_t(2) << std::size_t(6) << std::size_t(50);
 239
 240     QTest::newRow("coordinates (6, 3) should be same as 30 index")
 241         << std::size_t(6) << std::size_t(3) << std::size_t(30);
 242
 243     QTest::newRow("coordinates (8, 8) should be same as -1 index")
 244         << std::size_t(8) << std::size_t(8) << std::size_t(-1);
 245 }
 246
 247 void TestChessBoard::getPosition()
 248 {
 249     QFETCH(std::size_t, column);
 250     QFETCH(std::size_t, row);
 251     QFETCH(std::size_t, expected);
 252
 253     std::size_t position = ChessBoard::getPosition(column, row);
 254
 255     QCOMPARE(position, expected);
 256 }
 257
 258 // End of Tests
 259
 260 QTEST_MAIN(TestChessBoard)
 261 #include "testchessboard.moc"