538 lines
20 KiB
C++
538 lines
20 KiB
C++
/**
|
|
* @file llworldmap_test.cpp
|
|
* @author Merov Linden
|
|
* @date 2009-03-09
|
|
*
|
|
* $LicenseInfo:firstyear=2006&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2006-2009, Linden Research, Inc.
|
|
*
|
|
* Second Life Viewer Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in doc/GPL-license.txt in this distribution, or
|
|
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file doc/FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
// Precompiled header: almost always required for newview cpp files
|
|
#include "../llviewerprecompiledheaders.h"
|
|
// Class to test
|
|
#include "../llworldmap.h"
|
|
// Dependencies
|
|
#include "../llviewerimagelist.h"
|
|
#include "../llworldmapmessage.h"
|
|
// Tut header
|
|
#include "../test/lltut.h"
|
|
|
|
// -------------------------------------------------------------------------------------------
|
|
// Stubbing: Declarations required to link and run the class being tested
|
|
// Notes:
|
|
// * Add here stubbed implementation of the few classes and methods used in the class to be tested
|
|
// * Add as little as possible (let the link errors guide you)
|
|
// * Do not make any assumption as to how those classes or methods work (i.e. don't copy/paste code)
|
|
// * A simulator for a class can be implemented here. Please comment and document thoroughly.
|
|
|
|
// Stub image calls
|
|
LLViewerImageList::LLViewerImageList() { }
|
|
LLViewerImageList::~LLViewerImageList() { }
|
|
LLViewerImageList gImageList;
|
|
LLViewerImage* LLViewerImageList::getImage(const LLUUID &image_id,
|
|
BOOL usemipmaps,
|
|
BOOL level_immediate,
|
|
LLGLint internal_format,
|
|
LLGLenum primary_format,
|
|
LLHost request_from_host)
|
|
{ return NULL; }
|
|
void LLViewerImage::setBoostLevel(S32 level) { }
|
|
void LLImageGL::setAddressMode(LLTexUnit::eTextureAddressMode mode) { }
|
|
|
|
// Stub related map calls
|
|
LLWorldMapMessage::LLWorldMapMessage() { }
|
|
LLWorldMapMessage::~LLWorldMapMessage() { }
|
|
void LLWorldMapMessage::sendItemRequest(U32 type, U64 handle) { }
|
|
void LLWorldMapMessage::sendMapBlockRequest(U16 min_x, U16 min_y, U16 max_x, U16 max_y, bool return_nonexistent) { }
|
|
LLWorldMipmap::LLWorldMipmap() { }
|
|
LLWorldMipmap::~LLWorldMipmap() { }
|
|
void LLWorldMipmap::reset() { }
|
|
void LLWorldMipmap::dropBoostLevels() { }
|
|
void LLWorldMipmap::equalizeBoostLevels() { }
|
|
LLPointer<LLViewerImage> LLWorldMipmap::getObjectsTile(U32 grid_x, U32 grid_y, S32 level, bool load)
|
|
{ return NULL; }
|
|
|
|
// Stub other stuff
|
|
BOOL gPacificDaylightTime;
|
|
|
|
// End Stubbing
|
|
// -------------------------------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------------------------------
|
|
// TUT
|
|
// -------------------------------------------------------------------------------------------
|
|
|
|
const F32 X_WORLD_TEST = 1000.0f * REGION_WIDTH_METERS;
|
|
const F32 Y_WORLD_TEST = 2000.0f * REGION_WIDTH_METERS;
|
|
const F32 Z_WORLD_TEST = 240.0f;
|
|
const std::string ITEM_NAME_TEST = "Item Foo";
|
|
const std::string TOOLTIP_TEST = "Tooltip Foo";
|
|
|
|
const std::string SIM_NAME_TEST = "Sim Foo";
|
|
|
|
namespace tut
|
|
{
|
|
// Test wrapper declarations
|
|
struct iteminfo_test
|
|
{
|
|
// Instance to be tested
|
|
LLItemInfo* mItem;
|
|
|
|
// Constructor and destructor of the test wrapper
|
|
iteminfo_test()
|
|
{
|
|
LLUUID id;
|
|
mItem = new LLItemInfo(X_WORLD_TEST, Y_WORLD_TEST, ITEM_NAME_TEST, id);
|
|
}
|
|
~iteminfo_test()
|
|
{
|
|
delete mItem;
|
|
}
|
|
};
|
|
|
|
struct siminfo_test
|
|
{
|
|
// Instance to be tested
|
|
LLSimInfo* mSim;
|
|
|
|
// Constructor and destructor of the test wrapper
|
|
siminfo_test()
|
|
{
|
|
U64 handle = to_region_handle_global(X_WORLD_TEST, Y_WORLD_TEST);
|
|
mSim = new LLSimInfo(handle);
|
|
}
|
|
~siminfo_test()
|
|
{
|
|
delete mSim;
|
|
}
|
|
};
|
|
|
|
struct worldmap_test
|
|
{
|
|
// Instance to be tested
|
|
LLWorldMap* mWorld;
|
|
|
|
// Constructor and destructor of the test wrapper
|
|
worldmap_test()
|
|
{
|
|
mWorld = LLWorldMap::getInstance();
|
|
}
|
|
~worldmap_test()
|
|
{
|
|
mWorld = NULL;
|
|
}
|
|
};
|
|
|
|
// Tut templating thingamagic: test group, object and test instance
|
|
typedef test_group<iteminfo_test> iteminfo_t;
|
|
typedef iteminfo_t::object iteminfo_object_t;
|
|
tut::iteminfo_t tut_iteminfo("iteminfo");
|
|
|
|
typedef test_group<siminfo_test> siminfo_t;
|
|
typedef siminfo_t::object siminfo_object_t;
|
|
tut::siminfo_t tut_siminfo("siminfo");
|
|
|
|
typedef test_group<worldmap_test> worldmap_t;
|
|
typedef worldmap_t::object worldmap_object_t;
|
|
tut::worldmap_t tut_worldmap("worldmap");
|
|
|
|
// ---------------------------------------------------------------------------------------
|
|
// Test functions
|
|
// Notes:
|
|
// * Test as many as you possibly can without requiring a full blown simulation of everything
|
|
// * The tests are executed in sequence so the test instance state may change between calls
|
|
// * Remember that you cannot test private methods with tut
|
|
// ---------------------------------------------------------------------------------------
|
|
|
|
// ---------------------------------------------------------------------------------------
|
|
// Test the LLItemInfo interface
|
|
// ---------------------------------------------------------------------------------------
|
|
template<> template<>
|
|
void iteminfo_object_t::test<1>()
|
|
{
|
|
// Test 1 : setCount() / getCount()
|
|
mItem->setCount(10);
|
|
ensure("LLItemInfo::setCount() test failed", mItem->getCount() == 10);
|
|
// Test 2 : setTooltip() / getToolTip()
|
|
std::string tooltip = TOOLTIP_TEST;
|
|
mItem->setTooltip(tooltip);
|
|
ensure("LLItemInfo::setTooltip() test failed", mItem->getToolTip() == TOOLTIP_TEST);
|
|
// Test 3 : setElevation() / getGlobalPosition()
|
|
mItem->setElevation(Z_WORLD_TEST);
|
|
LLVector3d pos = mItem->getGlobalPosition();
|
|
LLVector3d ref(X_WORLD_TEST, Y_WORLD_TEST, Z_WORLD_TEST);
|
|
ensure("LLItemInfo::getGlobalPosition() test failed", pos == ref);
|
|
// Test 4 : getName()
|
|
std::string name = mItem->getName();
|
|
ensure("LLItemInfo::getName() test failed", name == ITEM_NAME_TEST);
|
|
// Test 5 : isName()
|
|
ensure("LLItemInfo::isName() test failed", mItem->isName(name));
|
|
// Test 6 : getUUID()
|
|
LLUUID id;
|
|
ensure("LLItemInfo::getUUID() test failed", mItem->getUUID() == id);
|
|
// Test 7 : getRegionHandle()
|
|
U64 handle = to_region_handle_global(X_WORLD_TEST, Y_WORLD_TEST);
|
|
ensure("LLItemInfo::getRegionHandle() test failed", mItem->getRegionHandle() == handle);
|
|
}
|
|
// ---------------------------------------------------------------------------------------
|
|
// Test the LLSimInfo interface
|
|
// ---------------------------------------------------------------------------------------
|
|
// Test Setters and Accessors methods
|
|
template<> template<>
|
|
void siminfo_object_t::test<1>()
|
|
{
|
|
// Test 1 : setName() / getName()
|
|
std::string name = SIM_NAME_TEST;
|
|
mSim->setName(name);
|
|
ensure("LLSimInfo::setName() test failed", mSim->getName() == SIM_NAME_TEST);
|
|
// Test 2 : isName()
|
|
ensure("LLSimInfo::isName() test failed", mSim->isName(name));
|
|
// Test 3 : getGlobalPos()
|
|
LLVector3 local;
|
|
LLVector3d ref(X_WORLD_TEST, Y_WORLD_TEST, 0.0f);
|
|
LLVector3d pos = mSim->getGlobalPos(local);
|
|
ensure("LLSimInfo::getGlobalPos() test failed", pos == ref);
|
|
// Test 4 : getGlobalOrigin()
|
|
pos = mSim->getGlobalOrigin();
|
|
ensure("LLSimInfo::getGlobalOrigin() test failed", pos == ref);
|
|
// Test 5 : clearImage()
|
|
try {
|
|
mSim->clearImage();
|
|
} catch (...) {
|
|
fail("LLSimInfo::clearImage() test failed");
|
|
}
|
|
// Test 6 : dropImagePriority()
|
|
try {
|
|
mSim->dropImagePriority();
|
|
} catch (...) {
|
|
fail("LLSimInfo::dropImagePriority() test failed");
|
|
}
|
|
// Test 7 : updateAgentCount()
|
|
try {
|
|
mSim->updateAgentCount(0.0f);
|
|
} catch (...) {
|
|
fail("LLSimInfo::updateAgentCount() test failed");
|
|
}
|
|
// Test 8 : getAgentCount()
|
|
S32 agents = mSim->getAgentCount();
|
|
ensure("LLSimInfo::getAgentCount() test failed", agents == 0);
|
|
// Test 9 : setLandForSaleImage() / getLandForSaleImage()
|
|
LLUUID id;
|
|
mSim->setLandForSaleImage(id);
|
|
LLPointer<LLViewerImage> image = mSim->getLandForSaleImage();
|
|
ensure("LLSimInfo::getLandForSaleImage() test failed", image.isNull());
|
|
// Test 10 : isPG()
|
|
mSim->setAccess(SIM_ACCESS_PG);
|
|
ensure("LLSimInfo::isPG() test failed", mSim->isPG());
|
|
// Test 11 : isDown()
|
|
mSim->setAccess(SIM_ACCESS_DOWN);
|
|
ensure("LLSimInfo::isDown() test failed", mSim->isDown());
|
|
// Test 12 : Access strings can't be accessed from unit test...
|
|
//ensure("LLSimInfo::getAccessString() test failed", mSim->getAccessString() == "Offline");
|
|
// Test 13 : Region strings can't be accessed from unit test...
|
|
//mSim->setRegionFlags(REGION_FLAGS_SANDBOX);
|
|
//ensure("LLSimInfo::setRegionFlags() test failed", mSim->getFlagsString() == "Sandbox");
|
|
}
|
|
// Test management of LLInfoItem lists
|
|
template<> template<>
|
|
void siminfo_object_t::test<2>()
|
|
{
|
|
// Test 14 : clearItems()
|
|
try {
|
|
mSim->clearItems();
|
|
} catch (...) {
|
|
fail("LLSimInfo::clearItems() at init test failed");
|
|
}
|
|
|
|
// Test 15 : Verify that all the lists are empty
|
|
LLSimInfo::item_info_list_t list;
|
|
list = mSim->getTeleHub();
|
|
ensure("LLSimInfo::getTeleHub() empty at init test failed", list.empty());
|
|
list = mSim->getInfoHub();
|
|
ensure("LLSimInfo::getInfoHub() empty at init test failed", list.empty());
|
|
list = mSim->getPGEvent();
|
|
ensure("LLSimInfo::getPGEvent() empty at init test failed", list.empty());
|
|
list = mSim->getMatureEvent();
|
|
ensure("LLSimInfo::getMatureEvent() empty at init test failed", list.empty());
|
|
list = mSim->getAdultEvent();
|
|
ensure("LLSimInfo::getAdultEvent() empty at init test failed", list.empty());
|
|
list = mSim->getLandForSale();
|
|
ensure("LLSimInfo::getLandForSale() empty at init test failed", list.empty());
|
|
list = mSim->getLandForSaleAdult();
|
|
ensure("LLSimInfo::getLandForSaleAdult() empty at init test failed", list.empty());
|
|
list = mSim->getAgentLocation();
|
|
ensure("LLSimInfo::getAgentLocation() empty at init test failed", list.empty());
|
|
|
|
// Create an item to be inserted
|
|
LLUUID id;
|
|
LLItemInfo item(X_WORLD_TEST, Y_WORLD_TEST, ITEM_NAME_TEST, id);
|
|
|
|
// Insert the item in each list
|
|
mSim->insertTeleHub(item);
|
|
mSim->insertInfoHub(item);
|
|
mSim->insertPGEvent(item);
|
|
mSim->insertMatureEvent(item);
|
|
mSim->insertAdultEvent(item);
|
|
mSim->insertLandForSale(item);
|
|
mSim->insertLandForSaleAdult(item);
|
|
mSim->insertAgentLocation(item);
|
|
|
|
// Test 16 : Verify that the lists contain 1 item each
|
|
list = mSim->getTeleHub();
|
|
ensure("LLSimInfo::insertTeleHub() test failed", list.size() == 1);
|
|
list = mSim->getInfoHub();
|
|
ensure("LLSimInfo::insertInfoHub() test failed", list.size() == 1);
|
|
list = mSim->getPGEvent();
|
|
ensure("LLSimInfo::insertPGEvent() test failed", list.size() == 1);
|
|
list = mSim->getMatureEvent();
|
|
ensure("LLSimInfo::insertMatureEvent() test failed", list.size() == 1);
|
|
list = mSim->getAdultEvent();
|
|
ensure("LLSimInfo::insertAdultEvent() test failed", list.size() == 1);
|
|
list = mSim->getLandForSale();
|
|
ensure("LLSimInfo::insertLandForSale() test failed", list.size() == 1);
|
|
list = mSim->getLandForSaleAdult();
|
|
ensure("LLSimInfo::insertLandForSaleAdult() test failed", list.size() == 1);
|
|
list = mSim->getAgentLocation();
|
|
ensure("LLSimInfo::insertAgentLocation() test failed", list.size() == 1);
|
|
|
|
// Test 17 : clearItems()
|
|
try {
|
|
mSim->clearItems();
|
|
} catch (...) {
|
|
fail("LLSimInfo::clearItems() at end test failed");
|
|
}
|
|
|
|
// Test 18 : Verify that all the lists are empty again... *except* agent which is persisted!! (on purpose)
|
|
list = mSim->getTeleHub();
|
|
ensure("LLSimInfo::getTeleHub() empty after clear test failed", list.empty());
|
|
list = mSim->getInfoHub();
|
|
ensure("LLSimInfo::getInfoHub() empty after clear test failed", list.empty());
|
|
list = mSim->getPGEvent();
|
|
ensure("LLSimInfo::getPGEvent() empty after clear test failed", list.empty());
|
|
list = mSim->getMatureEvent();
|
|
ensure("LLSimInfo::getMatureEvent() empty after clear test failed", list.empty());
|
|
list = mSim->getAdultEvent();
|
|
ensure("LLSimInfo::getAdultEvent() empty after clear test failed", list.empty());
|
|
list = mSim->getLandForSale();
|
|
ensure("LLSimInfo::getLandForSale() empty after clear test failed", list.empty());
|
|
list = mSim->getLandForSaleAdult();
|
|
ensure("LLSimInfo::getLandForSaleAdult() empty after clear test failed", list.empty());
|
|
list = mSim->getAgentLocation();
|
|
ensure("LLSimInfo::getAgentLocation() empty after clear test failed", list.size() == 1);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------
|
|
// Test the LLWorldMap interface
|
|
// ---------------------------------------------------------------------------------------
|
|
// Test Setters and Accessors methods
|
|
template<> template<>
|
|
void worldmap_object_t::test<1>()
|
|
{
|
|
// Test 1 : reset()
|
|
try {
|
|
mWorld->reset();
|
|
} catch (...) {
|
|
fail("LLWorldMap::reset() at init test failed");
|
|
}
|
|
// Test 2 : clearImageRefs()
|
|
try {
|
|
mWorld->clearImageRefs();
|
|
} catch (...) {
|
|
fail("LLWorldMap::clearImageRefs() test failed");
|
|
}
|
|
// Test 3 : dropImagePriorities()
|
|
try {
|
|
mWorld->dropImagePriorities();
|
|
} catch (...) {
|
|
fail("LLWorldMap::dropImagePriorities() test failed");
|
|
}
|
|
// Test 4 : reloadItems()
|
|
try {
|
|
mWorld->reloadItems(true);
|
|
} catch (...) {
|
|
fail("LLWorldMap::reloadItems() test failed");
|
|
}
|
|
// Test 5 : updateRegions()
|
|
try {
|
|
mWorld->updateRegions(1000, 1000, 1004, 1004);
|
|
} catch (...) {
|
|
fail("LLWorldMap::updateRegions() test failed");
|
|
}
|
|
// Test 6 : equalizeBoostLevels()
|
|
try {
|
|
mWorld->equalizeBoostLevels();
|
|
} catch (...) {
|
|
fail("LLWorldMap::equalizeBoostLevels() test failed");
|
|
}
|
|
// Test 7 : getObjectsTile()
|
|
try {
|
|
LLPointer<LLViewerImage> image = mWorld->getObjectsTile((U32)(X_WORLD_TEST/REGION_WIDTH_METERS), (U32)(Y_WORLD_TEST/REGION_WIDTH_METERS), 1);
|
|
ensure("LLWorldMap::getObjectsTile() failed", image.isNull());
|
|
} catch (...) {
|
|
fail("LLWorldMap::getObjectsTile() test failed with exception");
|
|
}
|
|
}
|
|
// Test management of LLSimInfo lists
|
|
template<> template<>
|
|
void worldmap_object_t::test<2>()
|
|
{
|
|
// Test 8 : reset()
|
|
try {
|
|
mWorld->reset();
|
|
} catch (...) {
|
|
fail("LLWorldMap::reset() at init test failed");
|
|
}
|
|
|
|
// Test 9 : Verify that all the region list is empty
|
|
LLWorldMap::sim_info_map_t list;
|
|
list = mWorld->getRegionMap();
|
|
ensure("LLWorldMap::getRegionMap() empty at init test failed", list.empty());
|
|
|
|
// Test 10 : Insert a region
|
|
bool success;
|
|
LLUUID id;
|
|
std::string name_sim = SIM_NAME_TEST;
|
|
success = mWorld->insertRegion( U32(X_WORLD_TEST),
|
|
U32(Y_WORLD_TEST),
|
|
name_sim,
|
|
id,
|
|
SIM_ACCESS_PG,
|
|
REGION_FLAGS_SANDBOX);
|
|
list = mWorld->getRegionMap();
|
|
ensure("LLWorldMap::insertRegion() failed", success && (list.size() == 1));
|
|
|
|
// Test 11 : Insert an item in the same region -> number of regions doesn't increase
|
|
std::string name_item = ITEM_NAME_TEST;
|
|
success = mWorld->insertItem( U32(X_WORLD_TEST + REGION_WIDTH_METERS/2),
|
|
U32(Y_WORLD_TEST + REGION_WIDTH_METERS/2),
|
|
name_item,
|
|
id,
|
|
MAP_ITEM_LAND_FOR_SALE,
|
|
0, 0);
|
|
list = mWorld->getRegionMap();
|
|
ensure("LLWorldMap::insertItem() in existing region failed", success && (list.size() == 1));
|
|
|
|
// Test 12 : Insert an item in another region -> number of regions increases
|
|
success = mWorld->insertItem( U32(X_WORLD_TEST + REGION_WIDTH_METERS*2),
|
|
U32(Y_WORLD_TEST + REGION_WIDTH_METERS*2),
|
|
name_item,
|
|
id,
|
|
MAP_ITEM_LAND_FOR_SALE,
|
|
0, 0);
|
|
list = mWorld->getRegionMap();
|
|
ensure("LLWorldMap::insertItem() in unexisting region failed", success && (list.size() == 2));
|
|
|
|
// Test 13 : simInfoFromPosGlobal() in region
|
|
LLVector3d pos1( X_WORLD_TEST + REGION_WIDTH_METERS*2 + REGION_WIDTH_METERS/2,
|
|
Y_WORLD_TEST + REGION_WIDTH_METERS*2 + REGION_WIDTH_METERS/2,
|
|
0.0f);
|
|
LLSimInfo* sim;
|
|
sim = mWorld->simInfoFromPosGlobal(pos1);
|
|
ensure("LLWorldMap::simInfoFromPosGlobal() test on existing region failed", sim != NULL);
|
|
|
|
// Test 14 : simInfoFromPosGlobal() outside region
|
|
LLVector3d pos2( X_WORLD_TEST + REGION_WIDTH_METERS*4 + REGION_WIDTH_METERS/2,
|
|
Y_WORLD_TEST + REGION_WIDTH_METERS*4 + REGION_WIDTH_METERS/2,
|
|
0.0f);
|
|
sim = mWorld->simInfoFromPosGlobal(pos2);
|
|
ensure("LLWorldMap::simInfoFromPosGlobal() test outside region failed", sim == NULL);
|
|
|
|
// Test 15 : simInfoFromName()
|
|
sim = mWorld->simInfoFromName(name_sim);
|
|
ensure("LLWorldMap::simInfoFromName() test on existing region failed", sim != NULL);
|
|
|
|
// Test 16 : simInfoFromHandle()
|
|
U64 handle = to_region_handle_global(X_WORLD_TEST, Y_WORLD_TEST);
|
|
sim = mWorld->simInfoFromHandle(handle);
|
|
ensure("LLWorldMap::simInfoFromHandle() test on existing region failed", sim != NULL);
|
|
|
|
// Test 17 : simNameFromPosGlobal()
|
|
LLVector3d pos3( X_WORLD_TEST + REGION_WIDTH_METERS/2,
|
|
Y_WORLD_TEST + REGION_WIDTH_METERS/2,
|
|
0.0f);
|
|
success = mWorld->simNameFromPosGlobal(pos3, name_sim);
|
|
ensure("LLWorldMap::simNameFromPosGlobal() test on existing region failed", success && (name_sim == SIM_NAME_TEST));
|
|
|
|
// Test 18 : reset()
|
|
try {
|
|
mWorld->reset();
|
|
} catch (...) {
|
|
fail("LLWorldMap::reset() at end test failed");
|
|
}
|
|
|
|
// Test 19 : Verify that all the region list is empty
|
|
list = mWorld->getRegionMap();
|
|
ensure("LLWorldMap::getRegionMap() empty at end test failed", list.empty());
|
|
}
|
|
// Test tracking
|
|
template<> template<>
|
|
void worldmap_object_t::test<3>()
|
|
{
|
|
// Point to track
|
|
LLVector3d pos( X_WORLD_TEST + REGION_WIDTH_METERS/2, Y_WORLD_TEST + REGION_WIDTH_METERS/2, Z_WORLD_TEST);
|
|
|
|
// Test 20 : no tracking
|
|
mWorld->cancelTracking();
|
|
ensure("LLWorldMap::cancelTracking() at begin test failed", mWorld->isTracking() == false);
|
|
|
|
// Test 21 : set tracking
|
|
mWorld->setTracking(pos);
|
|
ensure("LLWorldMap::setTracking() failed", mWorld->isTracking() && !mWorld->isTrackingValidLocation());
|
|
|
|
// Test 22 : set click and commit flags
|
|
mWorld->setTrackingDoubleClick();
|
|
ensure("LLWorldMap::setTrackingDoubleClick() failed", mWorld->isTrackingDoubleClick());
|
|
mWorld->setTrackingCommit();
|
|
ensure("LLWorldMap::setTrackingCommit() failed", mWorld->isTrackingCommit());
|
|
|
|
// Test 23 : in rectangle test
|
|
bool inRect = mWorld->isTrackingInRectangle( X_WORLD_TEST, Y_WORLD_TEST,
|
|
X_WORLD_TEST + REGION_WIDTH_METERS,
|
|
Y_WORLD_TEST + REGION_WIDTH_METERS);
|
|
ensure("LLWorldMap::isTrackingInRectangle() in rectangle failed", inRect);
|
|
inRect = mWorld->isTrackingInRectangle( X_WORLD_TEST + REGION_WIDTH_METERS,
|
|
Y_WORLD_TEST + REGION_WIDTH_METERS,
|
|
X_WORLD_TEST + 2 * REGION_WIDTH_METERS,
|
|
Y_WORLD_TEST + 2 * REGION_WIDTH_METERS);
|
|
ensure("LLWorldMap::isTrackingInRectangle() outside rectangle failed", !inRect);
|
|
|
|
// Test 24 : set tracking to valid and invalid
|
|
mWorld->setTrackingValid();
|
|
ensure("LLWorldMap::setTrackingValid() failed", mWorld->isTrackingValidLocation() && !mWorld->isTrackingInvalidLocation());
|
|
mWorld->setTrackingInvalid();
|
|
ensure("LLWorldMap::setTrackingInvalid() failed", !mWorld->isTrackingValidLocation() && mWorld->isTrackingInvalidLocation());
|
|
|
|
// Test 25 : getTrackedPositionGlobal()
|
|
LLVector3d res = mWorld->getTrackedPositionGlobal();
|
|
ensure("LLWorldMap::getTrackedPositionGlobal() failed", res == pos);
|
|
|
|
// Test 26 : reset tracking
|
|
mWorld->cancelTracking();
|
|
ensure("LLWorldMap::cancelTracking() at end test failed", mWorld->isTracking() == false);
|
|
}
|
|
}
|