253 changes: 253 additions & 0 deletions src/unittest/test_noderesolver.cpp
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,253 @@
/*
Minetest
Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include "test.h"

#include "exceptions.h"
#include "gamedef.h"
#include "nodedef.h"


class TestNodeResolver : public TestBase {
public:
TestNodeResolver() { TestManager::registerTestModule(this); }
const char *getName() { return "TestNodeResolver"; }

void runTests(IGameDef *gamedef);

void testNodeResolving(INodeDefManager *ndef);
void testPendingResolveCancellation(INodeDefManager *ndef);
void testDirectResolveMethod(INodeDefManager *ndef);
void testNoneResolveMethod(INodeDefManager *ndef);
};

static TestNodeResolver g_test_instance;

void TestNodeResolver::runTests(IGameDef *gamedef)
{
IWritableNodeDefManager *parent_ndef;
INodeDefManager *ndef;

parent_ndef = (IWritableNodeDefManager *)gamedef->getNodeDefManager();

ndef = parent_ndef->clone();
TEST(testNodeResolving, ndef);
delete ndef;

ndef = parent_ndef->clone();
TEST(testPendingResolveCancellation, ndef);
delete ndef;

ndef = parent_ndef->clone();
TEST(testDirectResolveMethod, ndef);
delete ndef;

ndef = parent_ndef->clone();
TEST(testNoneResolveMethod, ndef);
delete ndef;
}

class Foobar : public NodeResolver {
public:
void resolveNodeNames();

content_t test_nr_node1;
content_t test_nr_node2;
content_t test_nr_node3;
content_t test_nr_node4;
content_t test_nr_node5;
std::vector<content_t> test_nr_list;
std::vector<content_t> test_nr_list_group;
std::vector<content_t> test_nr_list_required;
std::vector<content_t> test_nr_list_empty;
};

class Foobaz : public NodeResolver {
public:
void resolveNodeNames();

content_t test_content1;
content_t test_content2;
};

////////////////////////////////////////////////////////////////////////////////

void Foobar::resolveNodeNames()
{
UASSERT(getIdFromNrBacklog(&test_nr_node1, "", CONTENT_IGNORE) == true);
UASSERT(getIdsFromNrBacklog(&test_nr_list) == true);
UASSERT(getIdsFromNrBacklog(&test_nr_list_group) == true);
UASSERT(getIdsFromNrBacklog(&test_nr_list_required,
true, CONTENT_AIR) == false);
UASSERT(getIdsFromNrBacklog(&test_nr_list_empty) == true);

UASSERT(getIdFromNrBacklog(&test_nr_node2, "", CONTENT_IGNORE) == true);
UASSERT(getIdFromNrBacklog(&test_nr_node3,
"default:brick", CONTENT_IGNORE) == true);
UASSERT(getIdFromNrBacklog(&test_nr_node4,
"default:gobbledygook", CONTENT_AIR) == false);
UASSERT(getIdFromNrBacklog(&test_nr_node5, "", CONTENT_IGNORE) == false);
}


void Foobaz::resolveNodeNames()
{
UASSERT(getIdFromNrBacklog(&test_content1, "", CONTENT_IGNORE) == true);
UASSERT(getIdFromNrBacklog(&test_content2, "", CONTENT_IGNORE) == false);
}


void TestNodeResolver::testNodeResolving(INodeDefManager *ndef)
{
Foobar foobar;
size_t i;

foobar.m_nodenames.push_back("default:torch");

foobar.m_nodenames.push_back("default:dirt_with_grass");
foobar.m_nodenames.push_back("default:water");
foobar.m_nodenames.push_back("default:abloobloobloo");
foobar.m_nodenames.push_back("default:stone");
foobar.m_nodenames.push_back("default:shmegoldorf");
foobar.m_nnlistsizes.push_back(5);

foobar.m_nodenames.push_back("group:liquids");
foobar.m_nnlistsizes.push_back(1);

foobar.m_nodenames.push_back("default:warf");
foobar.m_nodenames.push_back("default:stone");
foobar.m_nodenames.push_back("default:bloop");
foobar.m_nnlistsizes.push_back(3);

foobar.m_nnlistsizes.push_back(0);

foobar.m_nodenames.push_back("default:brick");
foobar.m_nodenames.push_back("default:desert_stone");
foobar.m_nodenames.push_back("default:shnitzle");

ndef->pendNodeResolve(&foobar, NODE_RESOLVE_DEFERRED);
UASSERT(foobar.m_ndef == ndef);

ndef->setNodeRegistrationStatus(true);
ndef->runNodeResolveCallbacks();

// Check that we read single nodes successfully
UASSERTEQ(content_t, foobar.test_nr_node1, t_CONTENT_TORCH);
UASSERTEQ(content_t, foobar.test_nr_node2, t_CONTENT_BRICK);
UASSERTEQ(content_t, foobar.test_nr_node3, t_CONTENT_BRICK);
UASSERTEQ(content_t, foobar.test_nr_node4, CONTENT_AIR);
UASSERTEQ(content_t, foobar.test_nr_node5, CONTENT_IGNORE);

// Check that we read all the regular list items
static const content_t expected_test_nr_list[] = {
t_CONTENT_GRASS,
t_CONTENT_WATER,
t_CONTENT_STONE,
};
UASSERTEQ(size_t, foobar.test_nr_list.size(), 3);
for (i = 0; i != foobar.test_nr_list.size(); i++)
UASSERTEQ(content_t, foobar.test_nr_list[i], expected_test_nr_list[i]);

// Check that we read all the list items that were from a group entry
static const content_t expected_test_nr_list_group[] = {
t_CONTENT_WATER,
t_CONTENT_LAVA,
};
UASSERTEQ(size_t, foobar.test_nr_list_group.size(), 2);
for (i = 0; i != foobar.test_nr_list_group.size(); i++) {
UASSERT(CONTAINS(foobar.test_nr_list_group,
expected_test_nr_list_group[i]));
}

// Check that we read all the items we're able to in a required list
static const content_t expected_test_nr_list_required[] = {
CONTENT_AIR,
t_CONTENT_STONE,
CONTENT_AIR,
};
UASSERTEQ(size_t, foobar.test_nr_list_required.size(), 3);
for (i = 0; i != foobar.test_nr_list_required.size(); i++)
UASSERTEQ(content_t, foobar.test_nr_list_required[i],
expected_test_nr_list_required[i]);

// Check that the edge case of 0 is successful
UASSERTEQ(size_t, foobar.test_nr_list_empty.size(), 0);
}


void TestNodeResolver::testPendingResolveCancellation(INodeDefManager *ndef)
{
Foobaz foobaz1;
foobaz1.test_content1 = 1234;
foobaz1.test_content2 = 5678;
foobaz1.m_nodenames.push_back("default:dirt_with_grass");
foobaz1.m_nodenames.push_back("default:abloobloobloo");
ndef->pendNodeResolve(&foobaz1, NODE_RESOLVE_DEFERRED);

Foobaz foobaz2;
foobaz2.test_content1 = 1234;
foobaz2.test_content2 = 5678;
foobaz2.m_nodenames.push_back("default:dirt_with_grass");
foobaz2.m_nodenames.push_back("default:abloobloobloo");
ndef->pendNodeResolve(&foobaz2, NODE_RESOLVE_DEFERRED);

ndef->cancelNodeResolveCallback(&foobaz1);

ndef->setNodeRegistrationStatus(true);
ndef->runNodeResolveCallbacks();

UASSERT(foobaz1.test_content1 == 1234);
UASSERT(foobaz1.test_content2 == 5678);
UASSERT(foobaz2.test_content1 == t_CONTENT_GRASS);
UASSERT(foobaz2.test_content2 == CONTENT_IGNORE);
}


void TestNodeResolver::testDirectResolveMethod(INodeDefManager *ndef)
{
Foobaz foobaz;

foobaz.m_nodenames.push_back("default:dirt_with_grass");
foobaz.m_nodenames.push_back("default:abloobloobloo");

UASSERTEQ(std::string, foobaz.getNodeName(1), "default:abloobloobloo");

ndef->pendNodeResolve(&foobaz, NODE_RESOLVE_DIRECT);

UASSERTEQ(content_t, foobaz.test_content1, t_CONTENT_GRASS);
UASSERTEQ(content_t, foobaz.test_content2, CONTENT_IGNORE);

// We expect this to be *different* because the resolution of this node had
// failed. The internal nodename buffer is cleared and lookups should now
// use the nodedef manager.
UASSERT(foobaz.getNodeName(1) != "default:abloobloobloo");
}


void TestNodeResolver::testNoneResolveMethod(INodeDefManager *ndef)
{
Foobaz foobaz;

foobaz.m_nodenames.push_back("default:dirt_with_grass");
foobaz.m_nodenames.push_back("default:abloobloobloo");

ndef->pendNodeResolve(&foobaz, NODE_RESOLVE_NONE);

UASSERTEQ(std::string, foobaz.getNodeName(1), "default:abloobloobloo");
}
8 changes: 4 additions & 4 deletions src/unittest/test_voxelalgorithms.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -69,7 +69,7 @@ void TestVoxelAlgorithms::testPropogateSunlight(INodeDefManager *ndef)
== LIGHT_SUN);
}

v.setNodeNoRef(v3s16(0,0,0), MapNode(CONTENT_STONE));
v.setNodeNoRef(v3s16(0,0,0), MapNode(t_CONTENT_STONE));

{
std::set<v3s16> light_sources;
Expand All @@ -91,7 +91,7 @@ void TestVoxelAlgorithms::testPropogateSunlight(INodeDefManager *ndef)
== 0);
}

v.setNodeNoRef(v3s16(1,3,2), MapNode(CONTENT_STONE));
v.setNodeNoRef(v3s16(1,3,2), MapNode(t_CONTENT_STONE));

{
std::set<v3s16> light_sources;
Expand Down Expand Up @@ -180,8 +180,8 @@ void TestVoxelAlgorithms::testClearLightAndCollectSources(INodeDefManager *ndef)
}

VoxelArea a(v3s16(0,0,0), v3s16(2,2,2));
v.setNodeNoRef(v3s16(0,0,0), MapNode(CONTENT_STONE));
v.setNodeNoRef(v3s16(1,1,1), MapNode(CONTENT_TORCH));
v.setNodeNoRef(v3s16(0,0,0), MapNode(t_CONTENT_STONE));
v.setNodeNoRef(v3s16(1,1,1), MapNode(t_CONTENT_TORCH));

{
MapNode n(CONTENT_AIR);
Expand Down
6 changes: 3 additions & 3 deletions src/unittest/test_voxelmanipulator.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -87,10 +87,10 @@ void TestVoxelManipulator::testVoxelManipulator(INodeDefManager *nodedef)
v.print(infostream, nodedef);

infostream << "*** Setting (-1,0,-1)=2 ***" << std::endl;
v.setNodeNoRef(v3s16(-1,0,-1), MapNode(CONTENT_GRASS));
v.setNodeNoRef(v3s16(-1,0,-1), MapNode(t_CONTENT_GRASS));

v.print(infostream, nodedef);
UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == CONTENT_GRASS);
UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == t_CONTENT_GRASS);

infostream << "*** Reading from inexistent (0,0,-1) ***" << std::endl;

Expand All @@ -103,6 +103,6 @@ void TestVoxelManipulator::testVoxelManipulator(INodeDefManager *nodedef)
v.addArea(a);
v.print(infostream, nodedef);

UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == CONTENT_GRASS);
UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == t_CONTENT_GRASS);
EXCEPTION_CHECK(InvalidPositionException, v.getNode(v3s16(0,1,1)));
}