src/unittest/test_noderesolver.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   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
  22 #include "util/numeric.h"
  23 #include "exceptions.h"
  24 #include "gamedef.h"
  25 #include "nodedef.h"
  26
  27 #include <algorithm>
  28
  29
  30 class TestNodeResolver : public TestBase {
  31 public:
  32         TestNodeResolver() { TestManager::registerTestModule(this); }
  33         const char *getName() { return "TestNodeResolver"; }
  34
  35         void runTests(IGameDef *gamedef);
  36
  37         void testNodeResolving(NodeDefManager *ndef);
  38         void testPendingResolveCancellation(NodeDefManager *ndef);
  39         void testDirectResolveMethod(NodeDefManager *ndef);
  40         void testNoneResolveMethod(NodeDefManager *ndef);
  41 };
  42
  43 static TestNodeResolver g_test_instance;
  44
  45 void TestNodeResolver::runTests(IGameDef *gamedef)
  46 {
  47         NodeDefManager *ndef =
  48                 (NodeDefManager *)gamedef->getNodeDefManager();
  49
  50         ndef->resetNodeResolveState();
  51         TEST(testNodeResolving, ndef);
  52
  53         ndef->resetNodeResolveState();
  54         TEST(testPendingResolveCancellation, ndef);
  55 }
  56
  57 class Foobar : public NodeResolver {
  58 public:
  59         void resolveNodeNames();
  60
  61         content_t test_nr_node1;
  62         content_t test_nr_node2;
  63         content_t test_nr_node3;
  64         content_t test_nr_node4;
  65         content_t test_nr_node5;
  66         std::vector<content_t> test_nr_list;
  67         std::vector<content_t> test_nr_list_group;
  68         std::vector<content_t> test_nr_list_required;
  69         std::vector<content_t> test_nr_list_empty;
  70 };
  71
  72 class Foobaz : public NodeResolver {
  73 public:
  74         void resolveNodeNames();
  75
  76         content_t test_content1;
  77         content_t test_content2;
  78 };
  79
  80 ////////////////////////////////////////////////////////////////////////////////
  81
  82 void Foobar::resolveNodeNames()
  83 {
  84         UASSERT(getIdFromNrBacklog(&test_nr_node1, "", CONTENT_IGNORE) == true);
  85         UASSERT(getIdsFromNrBacklog(&test_nr_list) == true);
  86         UASSERT(getIdsFromNrBacklog(&test_nr_list_group) == true);
  87         UASSERT(getIdsFromNrBacklog(&test_nr_list_required,
  88                 true, CONTENT_AIR) == false);
  89         UASSERT(getIdsFromNrBacklog(&test_nr_list_empty) == true);
  90
  91         UASSERT(getIdFromNrBacklog(&test_nr_node2, "", CONTENT_IGNORE) == true);
  92         UASSERT(getIdFromNrBacklog(&test_nr_node3,
  93                 "default:brick", CONTENT_IGNORE) == true);
  94         UASSERT(getIdFromNrBacklog(&test_nr_node4,
  95                 "default:gobbledygook", CONTENT_AIR) == false);
  96         UASSERT(getIdFromNrBacklog(&test_nr_node5, "", CONTENT_IGNORE) == false);
  97 }
  98
  99
 100 void Foobaz::resolveNodeNames()
 101 {
 102         UASSERT(getIdFromNrBacklog(&test_content1, "", CONTENT_IGNORE) == true);
 103         UASSERT(getIdFromNrBacklog(&test_content2, "", CONTENT_IGNORE) == false);
 104 }
 105
 106
 107 void TestNodeResolver::testNodeResolving(NodeDefManager *ndef)
 108 {
 109         Foobar foobar;
 110         size_t i;
 111
 112         foobar.m_nodenames.emplace_back("default:torch");
 113
 114         foobar.m_nodenames.emplace_back("default:dirt_with_grass");
 115         foobar.m_nodenames.emplace_back("default:water");
 116         foobar.m_nodenames.emplace_back("default:abloobloobloo");
 117         foobar.m_nodenames.emplace_back("default:stone");
 118         foobar.m_nodenames.emplace_back("default:shmegoldorf");
 119         foobar.m_nnlistsizes.push_back(5);
 120
 121         foobar.m_nodenames.emplace_back("group:liquids");
 122         foobar.m_nnlistsizes.push_back(1);
 123
 124         foobar.m_nodenames.emplace_back("default:warf");
 125         foobar.m_nodenames.emplace_back("default:stone");
 126         foobar.m_nodenames.emplace_back("default:bloop");
 127         foobar.m_nnlistsizes.push_back(3);
 128
 129         foobar.m_nnlistsizes.push_back(0);
 130
 131         foobar.m_nodenames.emplace_back("default:brick");
 132         foobar.m_nodenames.emplace_back("default:desert_stone");
 133         foobar.m_nodenames.emplace_back("default:shnitzle");
 134
 135         ndef->pendNodeResolve(&foobar);
 136         UASSERT(foobar.m_ndef == ndef);
 137
 138         ndef->setNodeRegistrationStatus(true);
 139         ndef->runNodeResolveCallbacks();
 140
 141         // Check that we read single nodes successfully
 142         UASSERTEQ(content_t, foobar.test_nr_node1, t_CONTENT_TORCH);
 143         UASSERTEQ(content_t, foobar.test_nr_node2, t_CONTENT_BRICK);
 144         UASSERTEQ(content_t, foobar.test_nr_node3, t_CONTENT_BRICK);
 145         UASSERTEQ(content_t, foobar.test_nr_node4, CONTENT_AIR);
 146         UASSERTEQ(content_t, foobar.test_nr_node5, CONTENT_IGNORE);
 147
 148         // Check that we read all the regular list items
 149         static const content_t expected_test_nr_list[] = {
 150                 t_CONTENT_GRASS,
 151                 t_CONTENT_WATER,
 152                 t_CONTENT_STONE,
 153         };
 154         UASSERTEQ(size_t, foobar.test_nr_list.size(), 3);
 155         for (i = 0; i != foobar.test_nr_list.size(); i++)
 156                 UASSERTEQ(content_t, foobar.test_nr_list[i], expected_test_nr_list[i]);
 157
 158         // Check that we read all the list items that were from a group entry
 159         static const content_t expected_test_nr_list_group[] = {
 160                 t_CONTENT_WATER,
 161                 t_CONTENT_LAVA,
 162         };
 163         UASSERTEQ(size_t, foobar.test_nr_list_group.size(), 2);
 164         for (i = 0; i != foobar.test_nr_list_group.size(); i++) {
 165                 UASSERT(CONTAINS(foobar.test_nr_list_group,
 166                         expected_test_nr_list_group[i]));
 167         }
 168
 169         // Check that we read all the items we're able to in a required list
 170         static const content_t expected_test_nr_list_required[] = {
 171                 CONTENT_AIR,
 172                 t_CONTENT_STONE,
 173                 CONTENT_AIR,
 174         };
 175         UASSERTEQ(size_t, foobar.test_nr_list_required.size(), 3);
 176         for (i = 0; i != foobar.test_nr_list_required.size(); i++)
 177                 UASSERTEQ(content_t, foobar.test_nr_list_required[i],
 178                         expected_test_nr_list_required[i]);
 179
 180         // Check that the edge case of 0 is successful
 181         UASSERTEQ(size_t, foobar.test_nr_list_empty.size(), 0);
 182 }
 183
 184
 185 void TestNodeResolver::testPendingResolveCancellation(NodeDefManager *ndef)
 186 {
 187         Foobaz foobaz1;
 188         foobaz1.test_content1 = 1234;
 189         foobaz1.test_content2 = 5678;
 190         foobaz1.m_nodenames.emplace_back("default:dirt_with_grass");
 191         foobaz1.m_nodenames.emplace_back("default:abloobloobloo");
 192         ndef->pendNodeResolve(&foobaz1);
 193
 194         Foobaz foobaz2;
 195         foobaz2.test_content1 = 1234;
 196         foobaz2.test_content2 = 5678;
 197         foobaz2.m_nodenames.emplace_back("default:dirt_with_grass");
 198         foobaz2.m_nodenames.emplace_back("default:abloobloobloo");
 199         ndef->pendNodeResolve(&foobaz2);
 200
 201         ndef->cancelNodeResolveCallback(&foobaz1);
 202
 203         ndef->setNodeRegistrationStatus(true);
 204         ndef->runNodeResolveCallbacks();
 205
 206         UASSERT(foobaz1.test_content1 == 1234);
 207         UASSERT(foobaz1.test_content2 == 5678);
 208         UASSERT(foobaz2.test_content1 == t_CONTENT_GRASS);
 209         UASSERT(foobaz2.test_content2 == CONTENT_IGNORE);
 210 }