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_volume();
  34         void test_contains_voxelarea();
  35         void test_contains_point();
  36         void test_contains_i();
  37         void test_equal();
  38         void test_plus();
  39         void test_minor();
  40         void test_index_xyz_all_pos();
  41         void test_index_xyz_x_neg();
  42         void test_index_xyz_y_neg();
  43         void test_index_xyz_z_neg();
  44         void test_index_xyz_xy_neg();
  45         void test_index_xyz_xz_neg();
  46         void test_index_xyz_yz_neg();
  47         void test_index_xyz_all_neg();
  48         void test_index_v3s16_all_pos();
  49         void test_index_v3s16_x_neg();
  50         void test_index_v3s16_y_neg();
  51         void test_index_v3s16_z_neg();
  52         void test_index_v3s16_xy_neg();
  53         void test_index_v3s16_xz_neg();
  54         void test_index_v3s16_yz_neg();
  55         void test_index_v3s16_all_neg();
  56         void test_add_x();
  57         void test_add_y();
  58         void test_add_z();
  59         void test_add_p();
  60 };
  61
  62 static TestVoxelArea g_test_instance;
  63
  64 void TestVoxelArea::runTests(IGameDef *gamedef)
  65 {
  66         TEST(test_addarea);
  67         TEST(test_pad);
  68         TEST(test_volume);
  69         TEST(test_contains_voxelarea);
  70         TEST(test_contains_point);
  71         TEST(test_contains_i);
  72         TEST(test_equal);
  73         TEST(test_plus);
  74         TEST(test_minor);
  75         TEST(test_index_xyz_all_pos);
  76         TEST(test_index_xyz_x_neg);
  77         TEST(test_index_xyz_y_neg);
  78         TEST(test_index_xyz_z_neg);
  79         TEST(test_index_xyz_xy_neg);
  80         TEST(test_index_xyz_xz_neg);
  81         TEST(test_index_xyz_yz_neg);
  82         TEST(test_index_xyz_all_neg);
  83         TEST(test_index_v3s16_all_pos);
  84         TEST(test_index_v3s16_x_neg);
  85         TEST(test_index_v3s16_y_neg);
  86         TEST(test_index_v3s16_z_neg);
  87         TEST(test_index_v3s16_xy_neg);
  88         TEST(test_index_v3s16_xz_neg);
  89         TEST(test_index_v3s16_yz_neg);
  90         TEST(test_index_v3s16_all_neg);
  91         TEST(test_add_x);
  92         TEST(test_add_y);
  93         TEST(test_add_z);
  94         TEST(test_add_p);
  95 }
  96
  97 void TestVoxelArea::test_addarea()
  98 {
  99         VoxelArea v1(v3s16(-1447, 8854, -875), v3s16(-147, -9547, 669));
 100         VoxelArea v2(v3s16(-887, 4445, -5478), v3s16(447, -8779, 4778));
 101
 102         v1.addArea(v2);
 103         UASSERT(v1.MinEdge == v3s16(-1447, 4445, -5478));
 104         UASSERT(v1.MaxEdge == v3s16(447, -8779, 4778));
 105 }
 106
 107 void TestVoxelArea::test_pad()
 108 {
 109         VoxelArea v1(v3s16(-1447, 8854, -875), v3s16(-147, -9547, 669));
 110         v1.pad(v3s16(100, 200, 300));
 111
 112         UASSERT(v1.MinEdge == v3s16(-1547, 8654, -1175));
 113         UASSERT(v1.MaxEdge == v3s16(-47, -9347, 969));
 114 }
 115
 116 void TestVoxelArea::test_volume()
 117 {
 118         VoxelArea v1(v3s16(-1337, 447, -789), v3s16(-147, -9547, 669));
 119         UASSERTEQ(s32, v1.getVolume(), -184657133);
 120 }
 121
 122 void TestVoxelArea::test_contains_voxelarea()
 123 {
 124         VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
 125         UASSERTEQ(bool, v1.contains(VoxelArea(v3s16(-200, 10, 10), v3s16(-150, 10, 10))),
 126                         true);
 127         UASSERTEQ(bool, v1.contains(VoxelArea(v3s16(-2550, 10, 10), v3s16(10, 10, 10))),
 128                         false);
 129         UASSERTEQ(bool, v1.contains(VoxelArea(v3s16(-10, 10, 10), v3s16(3500, 10, 10))),
 130                         false);
 131         UASSERTEQ(bool,
 132                         v1.contains(VoxelArea(
 133                                         v3s16(-800, -400, 669), v3s16(-500, 200, 669))),
 134                         true);
 135         UASSERTEQ(bool,
 136                         v1.contains(VoxelArea(
 137                                         v3s16(-800, -400, 670), v3s16(-500, 200, 670))),
 138                         false);
 139 }
 140
 141 void TestVoxelArea::test_contains_point()
 142 {
 143         VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
 144         UASSERTEQ(bool, v1.contains(v3s16(-200, 10, 10)), true);
 145         UASSERTEQ(bool, v1.contains(v3s16(-10000, 10, 10)), false);
 146         UASSERTEQ(bool, v1.contains(v3s16(-100, 10000, 10)), false);
 147         UASSERTEQ(bool, v1.contains(v3s16(-100, 100, 10000)), false);
 148         UASSERTEQ(bool, v1.contains(v3s16(-100, 100, -10000)), false);
 149         UASSERTEQ(bool, v1.contains(v3s16(10000, 100, 10)), false);
 150 }
 151
 152 void TestVoxelArea::test_contains_i()
 153 {
 154         VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
 155         UASSERTEQ(bool, v1.contains(10), true);
 156         UASSERTEQ(bool, v1.contains(v1.getVolume()), false);
 157         UASSERTEQ(bool, v1.contains(v1.getVolume() - 1), true);
 158         UASSERTEQ(bool, v1.contains(v1.getVolume() + 1), false);
 159         UASSERTEQ(bool, v1.contains(-1), false)
 160
 161         VoxelArea v2(v3s16(10, 10, 10), v3s16(30, 30, 30));
 162         UASSERTEQ(bool, v2.contains(10), true);
 163         UASSERTEQ(bool, v2.contains(0), true);
 164         UASSERTEQ(bool, v2.contains(-1), false);
 165 }
 166
 167 void TestVoxelArea::test_equal()
 168 {
 169         VoxelArea v1(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669));
 170         UASSERTEQ(bool, v1 == VoxelArea(v3s16(-1337, -9547, -789), v3s16(-147, 750, 669)),
 171                         true);
 172         UASSERTEQ(bool, v1 == VoxelArea(v3s16(0, 0, 0), v3s16(-147, 750, 669)), false);
 173         UASSERTEQ(bool, v1 == VoxelArea(v3s16(0, 0, 0), v3s16(-147, 750, 669)), false);
 174         UASSERTEQ(bool, v1 == VoxelArea(v3s16(0, 0, 0), v3s16(0, 0, 0)), false);
 175 }
 176
 177 void TestVoxelArea::test_plus()
 178 {
 179         VoxelArea v1(v3s16(-10, -10, -10), v3s16(100, 100, 100));
 180         UASSERT(v1 + v3s16(10, 0, 0) ==
 181                         VoxelArea(v3s16(0, -10, -10), v3s16(110, 100, 100)));
 182         UASSERT(v1 + v3s16(10, -10, 0) ==
 183                         VoxelArea(v3s16(0, -20, -10), v3s16(110, 90, 100)));
 184         UASSERT(v1 + v3s16(0, 0, 35) ==
 185                         VoxelArea(v3s16(-10, -10, 25), v3s16(100, 100, 135)));
 186 }
 187
 188 void TestVoxelArea::test_minor()
 189 {
 190         VoxelArea v1(v3s16(-10, -10, -10), v3s16(100, 100, 100));
 191         UASSERT(v1 - v3s16(10, 0, 0) ==
 192                         VoxelArea(v3s16(-20, -10, -10), v3s16(90, 100, 100)));
 193         UASSERT(v1 - v3s16(10, -10, 0) ==
 194                         VoxelArea(v3s16(-20, 0, -10), v3s16(90, 110, 100)));
 195         UASSERT(v1 - v3s16(0, 0, 35) ==
 196                         VoxelArea(v3s16(-10, -10, -45), v3s16(100, 100, 65)));
 197 }
 198
 199 void TestVoxelArea::test_index_xyz_all_pos()
 200 {
 201         VoxelArea v1;
 202         UASSERTEQ(s32, v1.index(156, 25, 236), 155);
 203
 204         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 205         UASSERTEQ(s32, v2.index(156, 25, 236), 1267138774);
 206 }
 207
 208 void TestVoxelArea::test_index_xyz_x_neg()
 209 {
 210         VoxelArea v1;
 211         UASSERTEQ(s32, v1.index(-147, 25, 366), -148);
 212
 213         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 214         UASSERTEQ(s32, v2.index(-147, 25, 366), -870244825);
 215 }
 216
 217 void TestVoxelArea::test_index_xyz_y_neg()
 218 {
 219         VoxelArea v1;
 220         UASSERTEQ(s32, v1.index(247, -269, 100), 246);
 221
 222         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 223         UASSERTEQ(s32, v2.index(247, -269, 100), -989760747);
 224 }
 225
 226 void TestVoxelArea::test_index_xyz_z_neg()
 227 {
 228         VoxelArea v1;
 229         UASSERTEQ(s32, v1.index(244, 336, -887), 243);
 230
 231         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 232         UASSERTEQ(s32, v2.index(244, 336, -887), -191478876);
 233 }
 234
 235 void TestVoxelArea::test_index_xyz_xy_neg()
 236 {
 237         VoxelArea v1;
 238         UASSERTEQ(s32, v1.index(-365, -47, 6978), -366);
 239
 240         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 241         UASSERTEQ(s32, v2.index(-365, -47, 6978), 1493679101);
 242 }
 243
 244 void TestVoxelArea::test_index_xyz_yz_neg()
 245 {
 246         VoxelArea v1;
 247         UASSERTEQ(s32, v1.index(66, -58, -789), 65);
 248
 249         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 250         UASSERTEQ(s32, v2.index(66, -58, -789), 1435362734);
 251 }
 252
 253 void TestVoxelArea::test_index_xyz_xz_neg()
 254 {
 255         VoxelArea v1;
 256         UASSERTEQ(s32, v1.index(-36, 589, -992), -37);
 257
 258         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 259         UASSERTEQ(s32, v2.index(-36, 589, -992), -1934371362);
 260 }
 261
 262 void TestVoxelArea::test_index_xyz_all_neg()
 263 {
 264         VoxelArea v1;
 265         UASSERTEQ(s32, v1.index(-88, -99, -1474), -89);
 266
 267         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 268         UASSERTEQ(s32, v2.index(-88, -99, -1474), -1343473846);
 269 }
 270
 271 void TestVoxelArea::test_index_v3s16_all_pos()
 272 {
 273         VoxelArea v1;
 274         UASSERTEQ(s32, v1.index(v3s16(156, 25, 236)), 155);
 275
 276         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 277         UASSERTEQ(s32, v2.index(v3s16(156, 25, 236)), 1267138774);
 278 }
 279
 280 void TestVoxelArea::test_index_v3s16_x_neg()
 281 {
 282         VoxelArea v1;
 283         UASSERTEQ(s32, v1.index(v3s16(-147, 25, 366)), -148);
 284
 285         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 286         UASSERTEQ(s32, v2.index(v3s16(-147, 25, 366)), -870244825);
 287 }
 288
 289 void TestVoxelArea::test_index_v3s16_y_neg()
 290 {
 291         VoxelArea v1;
 292         UASSERTEQ(s32, v1.index(v3s16(247, -269, 100)), 246);
 293
 294         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 295         UASSERTEQ(s32, v2.index(v3s16(247, -269, 100)), -989760747);
 296 }
 297
 298 void TestVoxelArea::test_index_v3s16_z_neg()
 299 {
 300         VoxelArea v1;
 301         UASSERTEQ(s32, v1.index(v3s16(244, 336, -887)), 243);
 302
 303         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 304         UASSERTEQ(s32, v2.index(v3s16(244, 336, -887)), -191478876);
 305 }
 306
 307 void TestVoxelArea::test_index_v3s16_xy_neg()
 308 {
 309         VoxelArea v1;
 310         UASSERTEQ(s32, v1.index(v3s16(-365, -47, 6978)), -366);
 311
 312         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 313         UASSERTEQ(s32, v2.index(v3s16(-365, -47, 6978)), 1493679101);
 314 }
 315
 316 void TestVoxelArea::test_index_v3s16_yz_neg()
 317 {
 318         VoxelArea v1;
 319         UASSERTEQ(s32, v1.index(v3s16(66, -58, -789)), 65);
 320
 321         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 322         UASSERTEQ(s32, v2.index(v3s16(66, -58, -789)), 1435362734);
 323 }
 324
 325 void TestVoxelArea::test_index_v3s16_xz_neg()
 326 {
 327         VoxelArea v1;
 328         UASSERTEQ(s32, v1.index(v3s16(-36, 589, -992)), -37);
 329
 330         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 331         UASSERTEQ(s32, v2.index(v3s16(-36, 589, -992)), -1934371362);
 332 }
 333
 334 void TestVoxelArea::test_index_v3s16_all_neg()
 335 {
 336         VoxelArea v1;
 337         UASSERTEQ(s32, v1.index(v3s16(-88, -99, -1474)), -89);
 338
 339         VoxelArea v2(v3s16(756, 8854, -875), v3s16(-147, -9547, 669));
 340         UASSERTEQ(s32, v2.index(v3s16(-88, -99, -1474)), -1343473846);
 341 }
 342
 343 void TestVoxelArea::test_add_x()
 344 {
 345         v3s16 extent;
 346         u32 i = 4;
 347         VoxelArea::add_x(extent, i, 8);
 348         UASSERTEQ(u32, i, 12)
 349 }
 350
 351 void TestVoxelArea::test_add_y()
 352 {
 353         v3s16 extent(740, 16, 87);
 354         u32 i = 8;
 355         VoxelArea::add_y(extent, i, 88);
 356         UASSERTEQ(u32, i, 65128)
 357 }
 358
 359 void TestVoxelArea::test_add_z()
 360 {
 361         v3s16 extent(114, 80, 256);
 362         u32 i = 4;
 363         VoxelArea::add_z(extent, i, 8);
 364         UASSERTEQ(u32, i, 72964)
 365 }
 366
 367 void TestVoxelArea::test_add_p()
 368 {
 369         v3s16 extent(33, 14, 742);
 370         v3s16 a(15, 12, 369);
 371         u32 i = 4;
 372         VoxelArea::add_p(extent, i, a);
 373         UASSERTEQ(u32, i, 170893)
 374 }