src/unittest/test_voxelarea.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2018 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "test.h"
  21 #include "voxel.h"
  22
  23 class TestVoxelArea : public TestBase
  24 {
  25 public:
  26         TestVoxelArea() { TestManager::registerTestModule(this); }
  27         const char *getName() { return "TestVoxelArea"; }
  28
  29         void runTests(IGameDef *gamedef);
  30
  31         void test_addarea();
  32         void test_pad();
  33         void test_extent();
  34         void test_volume();
  35         void test_contains_voxelarea();
  36         void test_contains_point();
  37         void test_contains_i();
  38         void test_equal();
  39         void test_plus();
  40         void test_minor();
  41         void test_index_xyz_all_pos();
  42         void test_index_xyz_x_neg();
  43         void test_index_xyz_y_neg();
  44         void test_index_xyz_z_neg();
  45         void test_index_xyz_xy_neg();
  46         void test_index_xyz_xz_neg();
  47         void test_index_xyz_yz_neg();
  48         void test_index_xyz_all_neg();
  49         void test_index_v3s16_all_pos();
  50         void test_index_v3s16_x_neg();
  51         void test_index_v3s16_y_neg();
  52         void test_index_v3s16_z_neg();
  53         void test_index_v3s16_xy_neg();
  54         void test_index_v3s16_xz_neg();
  55         void test_index_v3s16_yz_neg();
  56         void test_index_v3s16_all_neg();
  57         void test_add_x();
  58         void test_add_y();
  59         void test_add_z();
  60         void test_add_p();
  61 };
  62
  63 static TestVoxelArea g_test_instance;
  64
  65 void TestVoxelArea::runTests(IGameDef *gamedef)
  66 {
  67         TEST(test_addarea);
  68         TEST(test_pad);
  69         TEST(test_extent);
  70         TEST(test_volume);
  71         TEST(test_contains_voxelarea);
  72         TEST(test_contains_point);
  73         TEST(test_contains_i);
  74         TEST(test_equal);
  75         TEST(test_plus);
  76         TEST(test_minor);
  77         TEST(test_index_xyz_all_pos);
  78         TEST(test_index_xyz_x_neg);
  79         TEST(test_index_xyz_y_neg);
  80         TEST(test_index_xyz_z_neg);
  81         TEST(test_index_xyz_xy_neg);
  82         TEST(test_index_xyz_xz_neg);
  83         TEST(test_index_xyz_yz_neg);
  84         TEST(test_index_xyz_all_neg);
  85         TEST(test_index_v3s16_all_pos);
  86         TEST(test_index_v3s16_x_neg);
  87         TEST(test_index_v3s16_y_neg);
  88         TEST(test_index_v3s16_z_neg);
  89         TEST(test_index_v3s16_xy_neg);
  90         TEST(test_index_v3s16_xz_neg);
  91         TEST(test_index_v3s16_yz_neg);
  92         TEST(test_index_v3s16_all_neg);
  93         TEST(test_add_x);
  94         TEST(test_add_y);
  95         TEST(test_add_z);
  96         TEST(test_add_p);
  97 }
  98
  99 void TestVoxelArea::test_addarea()
 100 {
 101         VoxelArea v1(v3s16(-1447, 8854, -875), v3s16(-147, -9547, 669));
 102         VoxelArea v2(v3s16(-887, 4445, -5478), v3s16(447, -8779, 4778));
 103
 104         v1.addArea(v2);
 105         UASSERT(v1.MinEdge == v3s16(-1447, 4445, -5478));
 106         UASSERT(v1.MaxEdge == v3s16(447, -8779, 4778));
 107 }
 108
 109 void TestVoxelArea::test_pad()
 110 {
 111         VoxelArea v1(v3s16(-1447, 8854, -875), v3s16(-147, -9547, 669));
 112         v1.pad(v3s16(100, 200, 300));
 113
 114         UASSERT(v1.MinEdge == v3s16(-1547, 8654, -1175));
 115         UASSERT(v1.MaxEdge == v3s16(-47, -9347, 969));
 116 }
 117
 118 void TestVoxelArea::test_extent()
 119 {
 120         VoxelArea v1(v3s16(-1337, -547, -789), v3s16(-147, 447, 669));
 121         UASSERT(v1.getExtent() == v3s16(1191, 995, 1459));
 122
 123         VoxelArea v2(v3s16(32493, -32507, 32753), v3s16(32508, -32492, -32768));
 124         UASSERT(v2.getExtent() == v3s16(16, 16, 16));
 125 }
 126
 127 void TestVoxelArea::test_volume()
 128 {
 129         VoxelArea v1(v3s16(-1337, -547, -789), v3s16(-147, 447, 669));
 130         UASSERTEQ(s32, v1.getVolume(), 1728980655);
 131
 132         VoxelArea v2(v3s16(32493, -32507, 32753), v3s16(32508, -32492, -32768));
 133         UASSERTEQ(s32, v2.getVolume(), 4096);
 134 }
 135
 136 void TestVoxelArea::test_contains_voxelarea()
 137 {
 138         VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
 139         UASSERTEQ(bool, v1.contains(VoxelArea(v3s16(-200, 10, 10), v3s16(-150, 10, 10))),
 140                         true);
 141         UASSERTEQ(bool, v1.contains(VoxelArea(v3s16(-2550, 10, 10), v3s16(10, 10, 10))),
 142                         false);
 143         UASSERTEQ(bool, v1.contains(VoxelArea(v3s16(-10, 10, 10), v3s16(3500, 10, 10))),
 144                         false);
 145         UASSERTEQ(bool,
 146                         v1.contains(VoxelArea(
 147                                         v3s16(-800, -400, 669), v3s16(-500, 200, 669))),
 148                         true);
 149         UASSERTEQ(bool,
 150                         v1.contains(VoxelArea(
 151                                         v3s16(-800, -400, 670), v3s16(-500, 200, 670))),
 152                         false);
 153 }
 154
 155 void TestVoxelArea::test_contains_point()
 156 {
 157         VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
 158         UASSERTEQ(bool, v1.contains(v3s16(-200, 10, 10)), true);
 159         UASSERTEQ(bool, v1.contains(v3s16(-10000, 10, 10)), false);
 160         UASSERTEQ(bool, v1.contains(v3s16(-100, 10000, 10)), false);
 161         UASSERTEQ(bool, v1.contains(v3s16(-100, 100, 10000)), false);
 162         UASSERTEQ(bool, v1.contains(v3s16(-100, 100, -10000)), false);
 163         UASSERTEQ(bool, v1.contains(v3s16(10000, 100, 10)), false);
 164 }
 165
 166 void TestVoxelArea::test_contains_i()
 167 {
 168         VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
 169         UASSERTEQ(bool, v1.contains(10), true);
 170         UASSERTEQ(bool, v1.contains(v1.getVolume()), false);
 171         UASSERTEQ(bool, v1.contains(v1.getVolume() - 1), true);
 172         UASSERTEQ(bool, v1.contains(v1.getVolume() + 1), false);
 173         UASSERTEQ(bool, v1.contains(-1), false)
 174
 175         VoxelArea v2(v3s16(10, 10, 10), v3s16(30, 30, 30));
 176         UASSERTEQ(bool, v2.contains(10), true);
 177         UASSERTEQ(bool, v2.contains(0), true);
 178         UASSERTEQ(bool, v2.contains(-1), false);
 179 }
 180
 181 void TestVoxelArea::test_equal()
 182 {
 183         VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
 184         UASSERTEQ(bool, v1 == VoxelArea(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669)),
 185                         true);
 186         UASSERTEQ(bool, v1 == VoxelArea(v3s16(0, 0, 0), v3s16(-147, 750, 669)), false);
 187         UASSERTEQ(bool, v1 == VoxelArea(v3s16(0, 0, 0), v3s16(-147, 750, 669)), false);
 188         UASSERTEQ(bool, v1 == VoxelArea(v3s16(0, 0, 0), v3s16(0, 0, 0)), false);
 189 }
 190
 191 void TestVoxelArea::test_plus()
 192 {
 193         VoxelArea v1(v3s16(-10, -10, -10), v3s16(100, 100, 100));
 194         UASSERT(v1 + v3s16(10, 0, 0) ==
 195                         VoxelArea(v3s16(0, -10, -10), v3s16(110, 100, 100)));
 196         UASSERT(v1 + v3s16(10, -10, 0) ==
 197                         VoxelArea(v3s16(0, -20, -10), v3s16(110, 90, 100)));
 198         UASSERT(v1 + v3s16(0, 0, 35) ==
 199                         VoxelArea(v3s16(-10, -10, 25), v3s16(100, 100, 135)));
 200 }
 201
 202 void TestVoxelArea::test_minor()
 203 {
 204         VoxelArea v1(v3s16(-10, -10, -10), v3s16(100, 100, 100));
 205         UASSERT(v1 - v3s16(10, 0, 0) ==
 206                         VoxelArea(v3s16(-20, -10, -10), v3s16(90, 100, 100)));
 207         UASSERT(v1 - v3s16(10, -10, 0) ==
 208                         VoxelArea(v3s16(-20, 0, -10), v3s16(90, 110, 100)));
 209         UASSERT(v1 - v3s16(0, 0, 35) ==
 210                         VoxelArea(v3s16(-10, -10, -45), v3s16(100, 100, 65)));
 211 }
 212
 213 void TestVoxelArea::test_index_xyz_all_pos()
 214 {
 215         VoxelArea v1;
 216         UASSERTEQ(s32, v1.index(156, 25, 236), 155);
 217
 218         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 219         UASSERTEQ(s32, v2.index(156, 25, 236), 1267138774);
 220 }
 221
 222 void TestVoxelArea::test_index_xyz_x_neg()
 223 {
 224         VoxelArea v1;
 225         UASSERTEQ(s32, v1.index(-147, 25, 366), -148);
 226
 227         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 228         UASSERTEQ(s32, v2.index(-147, 25, 366), -870244825);
 229 }
 230
 231 void TestVoxelArea::test_index_xyz_y_neg()
 232 {
 233         VoxelArea v1;
 234         UASSERTEQ(s32, v1.index(247, -269, 100), 246);
 235
 236         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 237         UASSERTEQ(s32, v2.index(247, -269, 100), -989760747);
 238 }
 239
 240 void TestVoxelArea::test_index_xyz_z_neg()
 241 {
 242         VoxelArea v1;
 243         UASSERTEQ(s32, v1.index(244, 336, -887), 243);
 244
 245         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 246         UASSERTEQ(s32, v2.index(244, 336, -887), -191478876);
 247 }
 248
 249 void TestVoxelArea::test_index_xyz_xy_neg()
 250 {
 251         VoxelArea v1;
 252         UASSERTEQ(s32, v1.index(-365, -47, 6978), -366);
 253
 254         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 255         UASSERTEQ(s32, v2.index(-365, -47, 6978), 1493679101);
 256 }
 257
 258 void TestVoxelArea::test_index_xyz_yz_neg()
 259 {
 260         VoxelArea v1;
 261         UASSERTEQ(s32, v1.index(66, -58, -789), 65);
 262
 263         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 264         UASSERTEQ(s32, v2.index(66, -58, -789), 1435362734);
 265 }
 266
 267 void TestVoxelArea::test_index_xyz_xz_neg()
 268 {
 269         VoxelArea v1;
 270         UASSERTEQ(s32, v1.index(-36, 589, -992), -37);
 271
 272         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 273         UASSERTEQ(s32, v2.index(-36, 589, -992), -1934371362);
 274 }
 275
 276 void TestVoxelArea::test_index_xyz_all_neg()
 277 {
 278         VoxelArea v1;
 279         UASSERTEQ(s32, v1.index(-88, -99, -1474), -89);
 280
 281         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 282         UASSERTEQ(s32, v2.index(-88, -99, -1474), -1343473846);
 283 }
 284
 285 void TestVoxelArea::test_index_v3s16_all_pos()
 286 {
 287         VoxelArea v1;
 288         UASSERTEQ(s32, v1.index(v3s16(156, 25, 236)), 155);
 289
 290         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 291         UASSERTEQ(s32, v2.index(v3s16(156, 25, 236)), 1267138774);
 292 }
 293
 294 void TestVoxelArea::test_index_v3s16_x_neg()
 295 {
 296         VoxelArea v1;
 297         UASSERTEQ(s32, v1.index(v3s16(-147, 25, 366)), -148);
 298
 299         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 300         UASSERTEQ(s32, v2.index(v3s16(-147, 25, 366)), -870244825);
 301 }
 302
 303 void TestVoxelArea::test_index_v3s16_y_neg()
 304 {
 305         VoxelArea v1;
 306         UASSERTEQ(s32, v1.index(v3s16(247, -269, 100)), 246);
 307
 308         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 309         UASSERTEQ(s32, v2.index(v3s16(247, -269, 100)), -989760747);
 310 }
 311
 312 void TestVoxelArea::test_index_v3s16_z_neg()
 313 {
 314         VoxelArea v1;
 315         UASSERTEQ(s32, v1.index(v3s16(244, 336, -887)), 243);
 316
 317         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 318         UASSERTEQ(s32, v2.index(v3s16(244, 336, -887)), -191478876);
 319 }
 320
 321 void TestVoxelArea::test_index_v3s16_xy_neg()
 322 {
 323         VoxelArea v1;
 324         UASSERTEQ(s32, v1.index(v3s16(-365, -47, 6978)), -366);
 325
 326         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 327         UASSERTEQ(s32, v2.index(v3s16(-365, -47, 6978)), 1493679101);
 328 }
 329
 330 void TestVoxelArea::test_index_v3s16_yz_neg()
 331 {
 332         VoxelArea v1;
 333         UASSERTEQ(s32, v1.index(v3s16(66, -58, -789)), 65);
 334
 335         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 336         UASSERTEQ(s32, v2.index(v3s16(66, -58, -789)), 1435362734);
 337 }
 338
 339 void TestVoxelArea::test_index_v3s16_xz_neg()
 340 {
 341         VoxelArea v1;
 342         UASSERTEQ(s32, v1.index(v3s16(-36, 589, -992)), -37);
 343
 344         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 345         UASSERTEQ(s32, v2.index(v3s16(-36, 589, -992)), -1934371362);
 346 }
 347
 348 void TestVoxelArea::test_index_v3s16_all_neg()
 349 {
 350         VoxelArea v1;
 351         UASSERTEQ(s32, v1.index(v3s16(-88, -99, -1474)), -89);
 352
 353         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 354         UASSERTEQ(s32, v2.index(v3s16(-88, -99, -1474)), -1343473846);
 355 }
 356
 357 void TestVoxelArea::test_add_x()
 358 {
 359         v3s16 extent;
 360         u32 i = 4;
 361         VoxelArea::add_x(extent, i, 8);
 362         UASSERTEQ(u32, i, 12)
 363 }
 364
 365 void TestVoxelArea::test_add_y()
 366 {
 367         v3s16 extent(740, 16, 87);
 368         u32 i = 8;
 369         VoxelArea::add_y(extent, i, 88);
 370         UASSERTEQ(u32, i, 65128)
 371 }
 372
 373 void TestVoxelArea::test_add_z()
 374 {
 375         v3s16 extent(114, 80, 256);
 376         u32 i = 4;
 377         VoxelArea::add_z(extent, i, 8);
 378         UASSERTEQ(u32, i, 72964)
 379 }
 380
 381 void TestVoxelArea::test_add_p()
 382 {
 383         v3s16 extent(33, 14, 742);
 384         v3s16 a(15, 12, 369);
 385         u32 i = 4;
 386         VoxelArea::add_p(extent, i, a);
 387         UASSERTEQ(u32, i, 170893)
 388 }