From 98ba22e7064db57316dfff1ae127feb3dceeb73e Mon Sep 17 00:00:00 2001 From: Justin Worthe Date: Thu, 31 Jul 2014 13:58:22 +0200 Subject: Initial commit --- docs/html/logic_tests_8cpp_source.html | 656 +++++++++++++++++++++++++++++++++ 1 file changed, 656 insertions(+) create mode 100644 docs/html/logic_tests_8cpp_source.html (limited to 'docs/html/logic_tests_8cpp_source.html') diff --git a/docs/html/logic_tests_8cpp_source.html b/docs/html/logic_tests_8cpp_source.html new file mode 100644 index 0000000..e3344b4 --- /dev/null +++ b/docs/html/logic_tests_8cpp_source.html @@ -0,0 +1,656 @@ + + + + +Rally X: tests/logicTests.cpp Source File + + + + + + + + + + + +
+ + +
+ + + + + + + + + + + + + +
+
Rally X + +
+
ELEN3009 Project by Justin Wernick and David Schneider
+
+
+ + + + + +
+
+
tests/logicTests.cpp
+
+
+Go to the documentation of this file.
00001 
+00055 #include <vector>
+00056 #include <list>
+00057 #include <utility>
+00058 using namespace std;
+00059 
+00060 #include <gtest/gtest.h>
+00061 
+00062 #include "../source/logic/CollisionDetector.h"
+00063 #include "../source/logic/PlayerCar.h"
+00064 #include "../source/logic/EnemyCar.h"
+00065 #include "../source/logic/Checkpoint.h"
+00066 #include "../source/logic/Rock.h"
+00067 #include "../source/logic/Smokescreen.h"
+00068 #include "../source/logic/Maze.h"
+00069 #include "../source/logic/MazeMath.h"
+00070 #include "../source/logic/DestroyedObjectPopup.h"
+00071 
+00075 TEST(Car, updateMovesPlayerUpInEmptyMaze)
+00076 {
+00077     Maze testMaze;
+00078     vector<pair<int,int> > walls;
+00079     testMaze.generateMaze(walls,5,5);
+00080 
+00081     PlayerCar player(2,2,Maze::UP);
+00082 
+00083     list<Smokescreen> smokescreens;
+00084     player.update(testMaze, smokescreens);
+00085 
+00086     double expectX = 2;
+00087     double expectY = 2-player.speed();
+00088     EXPECT_FLOAT_EQ(expectX, player.x());
+00089     EXPECT_FLOAT_EQ(expectY, player.y());
+00090 }
+00091 
+00095 TEST(Car, updateMovesPlayerDownInEmptyMaze)
+00096 {
+00097     Maze testMaze;
+00098     vector<pair<int,int> > walls;
+00099     testMaze.generateMaze(walls,5,5);
+00100 
+00101     PlayerCar player(2,2,Maze::DOWN);
+00102 
+00103     list<Smokescreen> smokescreens;
+00104     player.update(testMaze, smokescreens);
+00105 
+00106     double expectX = 2;
+00107     double expectY = 2+player.speed();
+00108     EXPECT_FLOAT_EQ(expectX, player.x());
+00109     EXPECT_FLOAT_EQ(expectY, player.y());
+00110 }
+00111 
+00115 TEST(Car, updateMovesPlayerLeftInEmptyMaze)
+00116 {
+00117     Maze testMaze;
+00118     vector<pair<int,int> > walls;
+00119     testMaze.generateMaze(walls,5,5);
+00120 
+00121     PlayerCar player(2,2,Maze::LEFT);
+00122 
+00123     list<Smokescreen> smokescreens;
+00124     player.update(testMaze, smokescreens);
+00125 
+00126     double expectX = 2-player.speed();
+00127     double expectY = 2;
+00128     EXPECT_FLOAT_EQ(expectX, player.x());
+00129     EXPECT_FLOAT_EQ(expectY, player.y());
+00130 }
+00131 
+00135 TEST(Car, updateMovesPlayerRightInEmptyMaze)
+00136 {
+00137     Maze testMaze;
+00138     vector<pair<int,int> > walls;
+00139     testMaze.generateMaze(walls,5,5);
+00140 
+00141     PlayerCar player(2,2,Maze::RIGHT);
+00142 
+00143     list<Smokescreen> smokescreens;
+00144     player.update(testMaze, smokescreens);
+00145 
+00146     double expectX = 2+player.speed();
+00147     double expectY = 2;
+00148     EXPECT_FLOAT_EQ(expectX, player.x());
+00149     EXPECT_FLOAT_EQ(expectY, player.y());
+00150 }
+00151 
+00155 TEST(Car, carNotMovedWhenPathUpBlocked)
+00156 {
+00157     Maze testMaze;
+00158     vector<pair<int,int> > walls;
+00159     walls.push_back(make_pair(3,3));
+00160     testMaze.generateMaze(walls,5,5);
+00161 
+00162     PlayerCar player(3,4,Maze::UP);
+00163 
+00164     list<Smokescreen> smokescreens;
+00165     player.update(testMaze, smokescreens);
+00166 
+00167     double expectX = 3;
+00168     double expectY = 4;
+00169     EXPECT_FLOAT_EQ(expectX, player.x());
+00170     EXPECT_FLOAT_EQ(expectY, player.y());
+00171 }
+00175 TEST(Car, carNotMovedWhenPathDownBlocked)
+00176 {
+00177     Maze testMaze;
+00178     vector<pair<int,int> > walls;
+00179     walls.push_back(make_pair(3,3));
+00180     testMaze.generateMaze(walls,5,5);
+00181 
+00182     PlayerCar player(3,2,Maze::DOWN);
+00183 
+00184     list<Smokescreen> smokescreens;
+00185     player.update(testMaze, smokescreens);
+00186 
+00187     double expectX = 3;
+00188     double expectY = 2;
+00189     EXPECT_FLOAT_EQ(expectX, player.x());
+00190     EXPECT_FLOAT_EQ(expectY, player.y());
+00191 }
+00195 TEST(Car, carNotMovedWhenPathLeftBlocked)
+00196 {
+00197     Maze testMaze;
+00198     vector<pair<int,int> > walls;
+00199     walls.push_back(make_pair(3,3));
+00200     testMaze.generateMaze(walls,5,5);
+00201 
+00202     PlayerCar player(4,3,Maze::LEFT);
+00203 
+00204     list<Smokescreen> smokescreens;
+00205     player.update(testMaze, smokescreens);
+00206 
+00207     double expectX = 4;
+00208     double expectY = 3;
+00209     EXPECT_FLOAT_EQ(expectX, player.x());
+00210     EXPECT_FLOAT_EQ(expectY, player.y());
+00211 }
+00215 TEST(Car, carNotMovedWhenPathRightBlocked)
+00216 {
+00217     Maze testMaze;
+00218     vector<pair<int,int> > walls;
+00219     walls.push_back(make_pair(3,3));
+00220     testMaze.generateMaze(walls,5,5);
+00221 
+00222     PlayerCar player(2,3,Maze::RIGHT);
+00223 
+00224     list<Smokescreen> smokescreens;
+00225     player.update(testMaze, smokescreens);
+00226 
+00227     double expectX = 2;
+00228     double expectY = 3;
+00229     EXPECT_FLOAT_EQ(expectX, player.x());
+00230     EXPECT_FLOAT_EQ(expectY, player.y());
+00231 }
+00232 
+00236 TEST(Car, carDoesNotMoveUpOutMaze)
+00237 {
+00238     Maze testMaze;
+00239     vector<pair<int,int> > walls;
+00240     testMaze.generateMaze(walls,5,5);
+00241 
+00242     PlayerCar player(3,0,Maze::UP);
+00243 
+00244     list<Smokescreen> smokescreens;
+00245     player.update(testMaze, smokescreens);
+00246 
+00247     double expectX = 3;
+00248     double expectY = 0;
+00249     EXPECT_FLOAT_EQ(expectX, player.x());
+00250     EXPECT_FLOAT_EQ(expectY, player.y());
+00251 }
+00255 TEST(Car, carDoesNotMoveDownOutMaze)
+00256 {
+00257     Maze testMaze;
+00258     vector<pair<int,int> > walls;
+00259     testMaze.generateMaze(walls,5,5);
+00260 
+00261     PlayerCar player(3,5,Maze::DOWN);
+00262 
+00263     list<Smokescreen> smokescreens;
+00264     player.update(testMaze, smokescreens);
+00265 
+00266     double expectX = 3;
+00267     double expectY = 5;
+00268     EXPECT_FLOAT_EQ(expectX, player.x());
+00269     EXPECT_FLOAT_EQ(expectY, player.y());
+00270 }
+00274 TEST(Car, carDoesNotMoveLeftOutMaze)
+00275 {
+00276     Maze testMaze;
+00277     vector<pair<int,int> > walls;
+00278     testMaze.generateMaze(walls,5,5);
+00279 
+00280     PlayerCar player(0,3,Maze::LEFT);
+00281 
+00282     list<Smokescreen> smokescreens;
+00283     player.update(testMaze, smokescreens);
+00284 
+00285     double expectX = 0;
+00286     double expectY = 3;
+00287     EXPECT_FLOAT_EQ(expectX, player.x());
+00288     EXPECT_FLOAT_EQ(expectY, player.y());
+00289 }
+00293 TEST(Car, carDoesNotMoveRightOutMaze)
+00294 {
+00295     Maze testMaze;
+00296     vector<pair<int,int> > walls;
+00297     testMaze.generateMaze(walls,5,5);
+00298 
+00299     PlayerCar player(5,3,Maze::RIGHT);
+00300 
+00301     list<Smokescreen> smokescreens;
+00302     player.update(testMaze, smokescreens);
+00303 
+00304     double expectX = 5;
+00305     double expectY = 3;
+00306     EXPECT_FLOAT_EQ(expectX, player.x());
+00307     EXPECT_FLOAT_EQ(expectY, player.y());
+00308 }
+00309 
+00313 TEST(Checkpoint, countIncrementsAndDecrements)
+00314 {
+00315     vector<Checkpoint> checkpoints;
+00316     EXPECT_EQ(0, Checkpoint::checkpointCount());
+00317 
+00318     for (int i=0; i<1000; ++i)
+00319     {
+00320         checkpoints.push_back(Checkpoint(i,i));
+00321     }
+00322     EXPECT_EQ(1000, Checkpoint::checkpointCount());
+00323 
+00324     //brackets to limit scope
+00325     {
+00326         Checkpoint extraCheck1(0,0);
+00327         Checkpoint extraCheck2 = extraCheck1;
+00328         EXPECT_EQ(1002, Checkpoint::checkpointCount());
+00329         extraCheck2 = extraCheck1;
+00330         EXPECT_EQ(1002, Checkpoint::checkpointCount());
+00331     }
+00332     EXPECT_EQ(1000, Checkpoint::checkpointCount());
+00333 
+00334     while(!checkpoints.empty())
+00335     {
+00336         checkpoints.pop_back();
+00337     }
+00338     EXPECT_EQ(0, Checkpoint::checkpointCount());
+00339 }
+00340 
+00344 TEST(CollisionDetector, playerAndEnemyBothDestroyed)
+00345 {
+00346     list<PlayerCar> players;
+00347     list<EnemyCar> enemies;
+00348     list<Checkpoint> checkpoints;
+00349     list<Rock> rocks;
+00350     list<Smokescreen> smokescreens;
+00351     CollisionDetector detector;
+00352 
+00353     players.push_back(PlayerCar(5,5));
+00354     players.push_back(PlayerCar(5,6));
+00355     players.push_back(PlayerCar(6,5));
+00356     players.push_back(PlayerCar(7,7.5));
+00357 
+00358     enemies.push_back(EnemyCar(5,6));
+00359     enemies.push_back(EnemyCar(4,5));
+00360     enemies.push_back(EnemyCar(6,6));
+00361     enemies.push_back(EnemyCar(6.5,8));
+00362 
+00363     detector.checkCollisions(players, enemies, checkpoints, rocks, smokescreens);
+00364 
+00365     list<PlayerCar>::const_iterator playerIter = players.begin();
+00366     EXPECT_FALSE(playerIter->destroyed());
+00367     ++playerIter;
+00368     EXPECT_TRUE(playerIter->destroyed());
+00369     ++playerIter;
+00370     EXPECT_FALSE(playerIter->destroyed());
+00371     ++playerIter;
+00372     EXPECT_TRUE(playerIter->destroyed());
+00373 
+00374     list<EnemyCar>::const_iterator enemyIter = enemies.begin();
+00375     EXPECT_TRUE(enemyIter->destroyed());
+00376     ++enemyIter;
+00377     EXPECT_FALSE(enemyIter->destroyed());
+00378     ++enemyIter;
+00379     EXPECT_FALSE(enemyIter->destroyed());
+00380     ++enemyIter;
+00381     EXPECT_TRUE(enemyIter->destroyed());
+00382 }
+00383 
+00387 TEST(CollisionDetector, playerDestroyedByRock)
+00388 {
+00389     list<PlayerCar> players;
+00390     list<EnemyCar> enemies;
+00391     list<Checkpoint> checkpoints;
+00392     list<Rock> rocks;
+00393     list<Smokescreen> smokescreens;
+00394     CollisionDetector detector;
+00395 
+00396     players.push_back(PlayerCar(5,5));
+00397     players.push_back(PlayerCar(5,6));
+00398     players.push_back(PlayerCar(6,5));
+00399     players.push_back(PlayerCar(7,7.5));
+00400 
+00401     rocks.push_back(Rock(5,6));
+00402     rocks.push_back(Rock(4,5));
+00403     rocks.push_back(Rock(6,6));
+00404     rocks.push_back(Rock(6.5,8));
+00405 
+00406     detector.checkCollisions(players, enemies, checkpoints, rocks, smokescreens);
+00407 
+00408     list<PlayerCar>::const_iterator playerIter = players.begin();
+00409     EXPECT_FALSE(playerIter->destroyed());
+00410     ++playerIter;
+00411     EXPECT_TRUE(playerIter->destroyed());
+00412     ++playerIter;
+00413     EXPECT_FALSE(playerIter->destroyed());
+00414     ++playerIter;
+00415     EXPECT_TRUE(playerIter->destroyed());
+00416 
+00417     list<Rock>::const_iterator rockIter = rocks.begin();
+00418     EXPECT_FALSE(rockIter->destroyed());
+00419     ++rockIter;
+00420     EXPECT_FALSE(rockIter->destroyed());
+00421     ++rockIter;
+00422     EXPECT_FALSE(rockIter->destroyed());
+00423     ++rockIter;
+00424     EXPECT_FALSE(rockIter->destroyed());
+00425 }
+00426 
+00430 TEST(CollisionDetector, checkpointDestroyedByPlayer)
+00431 {
+00432     list<PlayerCar> players;
+00433     list<EnemyCar> enemies;
+00434     list<Checkpoint> checkpoints;
+00435     list<Rock> rocks;
+00436     list<Smokescreen> smokescreens;
+00437     CollisionDetector detector;
+00438 
+00439     players.push_back(PlayerCar(5,5));
+00440     players.push_back(PlayerCar(5,6));
+00441     players.push_back(PlayerCar(6,5));
+00442     players.push_back(PlayerCar(7,7.5));
+00443 
+00444     checkpoints.push_back(Checkpoint(5,6));
+00445     checkpoints.push_back(Checkpoint(4,5));
+00446     checkpoints.push_back(Checkpoint(6,6));
+00447     checkpoints.push_back(Checkpoint(6.5,8));
+00448 
+00449     detector.checkCollisions(players, enemies, checkpoints, rocks, smokescreens);
+00450 
+00451     list<PlayerCar>::const_iterator playerIter = players.begin();
+00452     EXPECT_FALSE(playerIter->destroyed());
+00453     ++playerIter;
+00454     EXPECT_FALSE(playerIter->destroyed());
+00455     ++playerIter;
+00456     EXPECT_FALSE(playerIter->destroyed());
+00457     ++playerIter;
+00458     EXPECT_FALSE(playerIter->destroyed());
+00459 
+00460     list<Checkpoint>::const_iterator checkpointIter = checkpoints.begin();
+00461     EXPECT_TRUE(checkpointIter->destroyed());
+00462     ++checkpointIter;
+00463     EXPECT_FALSE(checkpointIter->destroyed());
+00464     ++checkpointIter;
+00465     EXPECT_FALSE(checkpointIter->destroyed());
+00466     ++checkpointIter;
+00467     EXPECT_TRUE(checkpointIter->destroyed());
+00468 }
+00469 
+00473 TEST(CollisionDetector, enemyStoppedBySmokescreen)
+00474 {
+00475     list<PlayerCar> players;
+00476     list<EnemyCar> enemies;
+00477     list<Checkpoint> checkpoints;
+00478     list<Rock> rocks;
+00479     list<Smokescreen> smokescreens;
+00480     CollisionDetector detector;
+00481 
+00482     enemies.push_back(EnemyCar(5,5));
+00483     enemies.push_back(EnemyCar(5,6));
+00484     enemies.push_back(EnemyCar(6,5));
+00485     enemies.push_back(EnemyCar(7,7.5));
+00486 
+00487     smokescreens.push_back(Smokescreen(5,6));
+00488     smokescreens.push_back(Smokescreen(4,5));
+00489     smokescreens.push_back(Smokescreen(6,6));
+00490     smokescreens.push_back(Smokescreen(6.5,8));
+00491 
+00492     detector.checkCollisions(players, enemies, checkpoints, rocks, smokescreens);
+00493 
+00494     list<EnemyCar>::const_iterator enemyIter = enemies.begin();
+00495     EXPECT_GT(enemyIter->speed(),0);
+00496     ++enemyIter;
+00497     EXPECT_FLOAT_EQ(0, enemyIter->speed());
+00498     ++enemyIter;
+00499     EXPECT_GT(enemyIter->speed(),0);
+00500     ++enemyIter;
+00501     EXPECT_FLOAT_EQ(0, enemyIter->speed());
+00502 }
+00503 
+00507 TEST(DestroyedObjectPopup, destroyedAfterSetTime)
+00508 {
+00509     DestroyedObjectPopup testPopup(3,2,BitmapStore::CRASHED_CAR);
+00510 
+00511     int i=0;
+00512     while (!testPopup.destroyed())
+00513     {
+00514         testPopup.update();
+00515         ++i;
+00516     }
+00517 
+00518     EXPECT_EQ(30,i);
+00519 }
+00520 
+00524 TEST(Maze, queryOutsideBoundsReturnsSolid)
+00525 {
+00526     Maze testMaze;
+00527     vector<pair<int,int> > walls;
+00528     testMaze.generateMaze(walls,5,5);
+00529 
+00530     EXPECT_FALSE(testMaze.getSolid(5,5));
+00531     EXPECT_FALSE(testMaze.getSolid(0,0));
+00532     EXPECT_TRUE(testMaze.getSolid(6,5));
+00533     EXPECT_TRUE(testMaze.getSolid(5,6));
+00534     EXPECT_TRUE(testMaze.getSolid(-1,3));
+00535     EXPECT_TRUE(testMaze.getSolid(3,-1));
+00536 }
+00537 
+00541 TEST(Maze, generationWithWallsWithoutObjectMax)
+00542 {
+00543     Maze testMaze;
+00544     vector<pair<int,int> > walls;
+00545     walls.push_back(make_pair(1,2));
+00546     walls.push_back(make_pair(4,3));
+00547     testMaze.generateMaze(walls);
+00548 
+00549     //test random empty blocks
+00550     EXPECT_FALSE(testMaze.getSolid(2,1));
+00551     EXPECT_FALSE(testMaze.getSolid(0,0));
+00552 
+00553     //test wall blocks
+00554     EXPECT_TRUE(testMaze.getSolid(1,2));
+00555     EXPECT_TRUE(testMaze.getSolid(4,3));
+00556 
+00557     //test bounds are being set right
+00558     EXPECT_TRUE(testMaze.getSolid(4,4));
+00559     EXPECT_TRUE(testMaze.getSolid(5,3));
+00560 }
+00561 
+00565 TEST(Maze, generationWithWallsWithObjectMax)
+00566 {
+00567     Maze testMaze;
+00568     vector<pair<int,int> > walls;
+00569     walls.push_back(make_pair(1,2));
+00570     walls.push_back(make_pair(4,3));
+00571     testMaze.generateMaze(walls,5,6);
+00572 
+00573     //test random empty blocks
+00574     EXPECT_FALSE(testMaze.getSolid(2,1));
+00575     EXPECT_FALSE(testMaze.getSolid(0,0));
+00576 
+00577     //test wall blocks
+00578     EXPECT_TRUE(testMaze.getSolid(1,2));
+00579     EXPECT_TRUE(testMaze.getSolid(4,3));
+00580 
+00581     //test bounds are being set right
+00582     EXPECT_FALSE(testMaze.getSolid(4,4));
+00583     EXPECT_FALSE(testMaze.getSolid(5,6));
+00584     EXPECT_TRUE(testMaze.getSolid(6,6));
+00585     EXPECT_TRUE(testMaze.getSolid(5,7));
+00586 }
+00587 
+00591 TEST(MazeMath, distanceGivesExpectedResult)
+00592 {
+00593     //right angle triange with sides of length 3, 4, and 5
+00594     double x1 = 1;
+00595     double y1 = 1;
+00596     double x2 = 4;
+00597     double y2 = 5;
+00598 
+00599     double expectedResult = 5;
+00600 
+00601     EXPECT_DOUBLE_EQ(expectedResult, MazeMath::distance(x1,y1,x2,y2));
+00602 }
+00603 
+00607 TEST(MazeMath, roundGivesExpectedResult)
+00608 {
+00609     //right angle triange with sides of length 3, 4, and 5
+00610     double roundUp = 5.5;
+00611     double roundDown = 5.49;
+00612 
+00613     double expectUp = 6;
+00614     double expectDown = 5;
+00615 
+00616     EXPECT_DOUBLE_EQ(expectUp, MazeMath::round(roundUp));
+00617     EXPECT_DOUBLE_EQ(expectDown, MazeMath::round(roundDown));
+00618 }
+00619 
+00626 TEST(PlayerCar, creationAndDestructionCanHappen)
+00627 {
+00628     EXPECT_NO_THROW({
+00629         vector<PlayerCar> players;
+00630         for (int i=0; i<10; ++i)
+00631         {
+00632             players.push_back(PlayerCar(i,i));
+00633         }
+00634         while(!players.empty())
+00635         {
+00636             players.pop_back();
+00637         }
+00638     });
+00639 
+00640     EXPECT_FALSE(al_is_system_installed());
+00641 }
+00642 
+00648 TEST(PlayerCar, playerSpeedAffectedByPetrol)
+00649 {
+00650     Maze testMaze;
+00651     vector<pair<int,int> > walls;
+00652     testMaze.generateMaze(walls,5,5);
+00653 
+00654     PlayerCar player(5,3,Maze::RIGHT);
+00655 
+00656     list<Smokescreen> smokescreens;
+00657     for (int i=0; i<1429; ++i)
+00658     {
+00659         player.update(testMaze, smokescreens);
+00660     }
+00661 
+00662     EXPECT_FLOAT_EQ(0, player.petrol());
+00663     EXPECT_FLOAT_EQ(0.05, player.speed());
+00664 
+00665     player.gotCheckpoint();
+00666     EXPECT_GT(player.petrol(), 0);
+00667     EXPECT_FLOAT_EQ(0.1, player.speed());
+00668 }
+00669 
+00673 TEST(Smokescreen, destroyedAfterSetTime)
+00674 {
+00675     Smokescreen testSmokescreen(3,2);
+00676 
+00677     int i=0;
+00678     while (!testSmokescreen.destroyed())
+00679     {
+00680         testSmokescreen.update();
+00681         ++i;
+00682     }
+00683 
+00684     EXPECT_EQ(60,i);
+00685 }
+
+
+ +
+ All Classes Files Functions Variables Typedefs Enumerations Enumerator
+ + +
+ +
+ + + +
+Generated on Wed Oct 5 2011 20:08:31 for Rally X by   +doxygen + 1.7.5.1 +
+ + + -- cgit v1.2.3