tst/world/BlockTest.cpp

   1 #include "BlockTest.hpp"
   2
   3 #include "world/Block.hpp"
   4
   5 #include <glm/gtx/io.hpp>
   6
   7 CPPUNIT_TEST_SUITE_REGISTRATION(blank::test::BlockTest);
   8
   9
  10 namespace blank {
  11 namespace test {
  12
  13 void BlockTest::setUp() {
  14 }
  15
  16 void BlockTest::tearDown() {
  17 }
  18
  19
  20 void BlockTest::testOrientation() {
  21         Block block(0, Block::FACE_DOWN, Block::TURN_LEFT);
  22         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  23                 "wrong block face after initialization",
  24                 block.GetFace(), Block::FACE_DOWN
  25         );
  26         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  27                 "wrong block turn after initialization",
  28                 block.GetTurn(), Block::TURN_LEFT
  29         );
  30
  31         block.SetFace(Block::FACE_BACK);
  32         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  33                 "changing block face has unexpected effect",
  34                 block.GetFace(), Block::FACE_BACK
  35         );
  36         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  37                 "changing block face affected turn",
  38                 block.GetTurn(), Block::TURN_LEFT
  39         );
  40
  41         block.SetTurn(Block::TURN_AROUND);
  42         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  43                 "changing block turn has unexpected effect",
  44                 block.GetTurn(), Block::TURN_AROUND
  45         );
  46         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  47                 "changing block turn affected face",
  48                 block.GetFace(), Block::FACE_BACK
  49         );
  50 }
  51
  52 void BlockTest::testFaceOpposite() {
  53         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  54                 "DOWN not opposite of UP",
  55                 Block::FACE_DOWN, Block::Opposite(Block::FACE_UP)
  56         );
  57         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  58                 "UP not opposite of DOWN",
  59                 Block::FACE_UP, Block::Opposite(Block::FACE_DOWN)
  60         );
  61         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  62                 "LEFT not opposite of RIGHT",
  63                 Block::FACE_LEFT, Block::Opposite(Block::FACE_RIGHT)
  64         );
  65         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  66                 "RIGHT not opposite of LEFT",
  67                 Block::FACE_RIGHT, Block::Opposite(Block::FACE_LEFT)
  68         );
  69         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  70                 "BACK not opposite of FRONT",
  71                 Block::FACE_BACK, Block::Opposite(Block::FACE_FRONT)
  72         );
  73         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  74                 "FRONT not opposite of BACk",
  75                 Block::FACE_FRONT, Block::Opposite(Block::FACE_BACK)
  76         );
  77 }
  78
  79 void BlockTest::testFaceAxis() {
  80         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  81                 "1/Y not axis of UP",
  82                 1, Block::Axis(Block::FACE_UP)
  83         );
  84         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  85                 "1/Y not axis of DOWN",
  86                 1, Block::Axis(Block::FACE_DOWN)
  87         );
  88         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  89                 "0/X not axis of RIGHT",
  90                 0, Block::Axis(Block::FACE_RIGHT)
  91         );
  92         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  93                 "0/X not axis of LEFT",
  94                 0, Block::Axis(Block::FACE_LEFT)
  95         );
  96         CPPUNIT_ASSERT_EQUAL_MESSAGE(
  97                 "2/Z not axis of FRONT",
  98                 2, Block::Axis(Block::FACE_FRONT)
  99         );
 100         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 101                 "2/Z not axis of BACK",
 102                 2, Block::Axis(Block::FACE_BACK)
 103         );
 104 }
 105
 106 void BlockTest::testFaceNormal() {
 107         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 108                 "[ 0, 1, 0 ] not normal of UP",
 109                 glm::ivec3(0, 1, 0), Block::FaceNormal(Block::FACE_UP)
 110         );
 111         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 112                 "[ 0, -1, 0 ] not normal of DOWN",
 113                 glm::ivec3(0, -1, 0), Block::FaceNormal(Block::FACE_DOWN)
 114         );
 115         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 116                 "[ 1, 0, 0 ] not normal of RIGHT",
 117                 glm::ivec3(1, 0, 0), Block::FaceNormal(Block::FACE_RIGHT)
 118         );
 119         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 120                 "[ -1, 0, 0 ] not normal of LEFT",
 121                 glm::ivec3(-1, 0, 0), Block::FaceNormal(Block::FACE_LEFT)
 122         );
 123         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 124                 "[ 0, 0, 1 ] not normal of FRONT",
 125                 glm::ivec3(0, 0, 1), Block::FaceNormal(Block::FACE_FRONT)
 126         );
 127         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 128                 "[ 0, 0, -1 ] not normal of BACK",
 129                 glm::ivec3(0, 0, -1), Block::FaceNormal(Block::FACE_BACK)
 130         );
 131 }
 132
 133 void BlockTest::testNormalFace() {
 134         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 135                 "UP not face of [ 0, 1, 0 ]",
 136                 Block::FACE_UP, Block::NormalFace(glm::vec3(0, 1, 0))
 137         );
 138         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 139                 "DOWN not face of [ 0, -1, 0 ]",
 140                 Block::FACE_DOWN, Block::NormalFace(glm::vec3(0, -1, 0))
 141         );
 142         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 143                 "RIGHT not face of [ 1, 0, 0 ]",
 144                 Block::FACE_RIGHT, Block::NormalFace(glm::vec3(1, 0, 0))
 145         );
 146         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 147                 "LEFT not face of [ -1, 0, 0 ]",
 148                 Block::FACE_LEFT, Block::NormalFace(glm::vec3(-1, 0, 0))
 149         );
 150         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 151                 "FRONT not face of [ 0, 0, 1 ]",
 152                 Block::FACE_FRONT, Block::NormalFace(glm::vec3(0, 0, 1))
 153         );
 154         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 155                 "BACK not face of [ 0, 0, -1 ]",
 156                 Block::FACE_BACK, Block::NormalFace(glm::vec3(0, 0, -1))
 157         );
 158 }
 159
 160
 161 void BlockTest::testFaceSet() {
 162         Block::FaceSet set;
 163         CPPUNIT_ASSERT_MESSAGE(
 164                 "default faceset not empty",
 165                 set.Empty()
 166         );
 167         for (int i = 0; i < Block::FACE_COUNT; ++i) {
 168                 CPPUNIT_ASSERT_MESSAGE(
 169                         "something set on default faceset",
 170                         !set.IsSet(Block::Face(i))
 171                 );
 172         }
 173         set.Fill();
 174         CPPUNIT_ASSERT_MESSAGE(
 175                 "not all set on filled faceset",
 176                 set.All()
 177         );
 178         for (int i = 0; i < Block::FACE_COUNT; ++i) {
 179                 CPPUNIT_ASSERT_MESSAGE(
 180                         "something not set on filled faceset",
 181                         set.IsSet(Block::Face(i))
 182                 );
 183         }
 184         set.Clear();
 185         CPPUNIT_ASSERT_MESSAGE(
 186                 "cleared faceset not empty",
 187                 set.Empty()
 188         );
 189         for (int i = 0; i < Block::FACE_COUNT; ++i) {
 190                 CPPUNIT_ASSERT_MESSAGE(
 191                         "something set on cleared faceset",
 192                         !set.IsSet(Block::Face(i))
 193                 );
 194                 set.Set(Block::Face(i));
 195                 CPPUNIT_ASSERT_MESSAGE(
 196                         "face not set after setting",
 197                         set.IsSet(Block::Face(i))
 198                 );
 199         }
 200         CPPUNIT_ASSERT_MESSAGE(
 201                 "set not filled after setting all faces",
 202                 set.All()
 203         );
 204         for (int i = 0; i < Block::FACE_COUNT; ++i) {
 205                 CPPUNIT_ASSERT_MESSAGE(
 206                         "something not set after setting all faces",
 207                         set.IsSet(Block::Face(i))
 208                 );
 209                 set.Unset(Block::Face(i));
 210                 CPPUNIT_ASSERT_MESSAGE(
 211                         "face set after unsetting",
 212                         !set.IsSet(Block::Face(i))
 213                 );
 214         }
 215         CPPUNIT_ASSERT_MESSAGE(
 216                 "set not empty after unsetting all faces",
 217                 set.Empty()
 218         );
 219 }
 220
 221
 222 void BlockTest::testDefaultBlock() {
 223         Block block;
 224         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 225                 "0 type id of default block",
 226                 Block::Type(0), block.type
 227         );
 228         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 229                 "identity transform of default block",
 230                 glm::mat4(1), block.Transform()
 231         );
 232         CPPUNIT_ASSERT_EQUAL_MESSAGE(
 233                 "no turn of default block",
 234                 Block::TURN_NONE, block.GetTurn()
 235         );
 236         for (int i = 0; i < Block::FACE_COUNT; ++i) {
 237                 CPPUNIT_ASSERT_EQUAL_MESSAGE(
 238                         "face is oriented face of default block",
 239                         Block::Face(i), block.OrientedFace(Block::Face(i))
 240                 );
 241         }
 242 }
 243
 244 }
 245 }