diff options
Diffstat (limited to 'indra/test/llscriptresource_tut.cpp')
| -rw-r--r-- | indra/test/llscriptresource_tut.cpp | 203 |
1 files changed, 203 insertions, 0 deletions
diff --git a/indra/test/llscriptresource_tut.cpp b/indra/test/llscriptresource_tut.cpp new file mode 100644 index 0000000000..e384c275a3 --- /dev/null +++ b/indra/test/llscriptresource_tut.cpp @@ -0,0 +1,203 @@ +/** + * @file llscriptresource_tut.cpp + * @brief Test LLScriptResource + * + * $LicenseInfo:firstyear=2008&license=viewergpl$ + * + * Copyright (c) 2006-2007, 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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$ + */ + +//#include <tut/tut.h> +#include "linden_common.h" + +#include "lltut.h" + +#include "llscriptresource.h" +#include "llscriptresourceconsumer.h" +#include "llscriptresourcepool.h" + +class TestConsumer : public LLScriptResourceConsumer +{ +public: + TestConsumer() + : mUsedURLs(0) + { } + + // LLScriptResourceConsumer interface: + S32 getUsedPublicURLs() const + { + return mUsedURLs; + } + + // Test details: + S32 mUsedURLs; +}; + + +namespace tut +{ + class LLScriptResourceTestData + { + }; + + typedef test_group<LLScriptResourceTestData> LLScriptResourceTestGroup; + typedef LLScriptResourceTestGroup::object LLScriptResourceTestObject; + LLScriptResourceTestGroup scriptResourceTestGroup("scriptResource"); + + template<> template<> + void LLScriptResourceTestObject::test<1>() + { + LLScriptResource resource; + U32 total = 42; + + resource.setTotal(total); + ensure_equals("Verify set/get total", resource.getTotal(), total); + ensure_equals("Verify all resources are initially available",resource.getAvailable(),total); + + // Requesting too many, releasing non-allocated + ensure("Request total + 1 resources should fail",!resource.request(total + 1)); + ensure_equals("Verify all resources available after failed request",resource.getAvailable(),total); + + ensure("Releasing resources when none allocated should fail",!resource.release()); + ensure_equals("All resources should be available after failed release",resource.getAvailable(),total); + + ensure("Request one resource", resource.request()); + ensure_equals("Verify available resources after successful request",resource.getAvailable(),total - 1); + + // Is this right? Or should we release all used resources if we try to release more than are currently used? + ensure("Release more resources than allocated",!resource.release(2)); + ensure_equals("Verify resource availability after failed release",resource.getAvailable(),total - 1); + + ensure("Release a resource",resource.release()); + ensure_equals("Verify all resources available after successful release",resource.getAvailable(),total); + } + + + template<> template<> + void LLScriptResourceTestObject::test<2>() + { + LLScriptResource resource; + U32 total = 42; + + resource.setTotal(total); + + S32 resources_to_request = 30; + ensure("Get multiple resources resources",resource.request(resources_to_request)); + ensure_equals("Verify available resources is correct after request of multiple resources",resource.getAvailable(), total - resources_to_request); + + S32 resources_to_release = (resources_to_request / 2); + ensure("Release some resources",resource.release(resources_to_release)); + + S32 expected_available = (total - resources_to_request + resources_to_release); + ensure_equals("Verify available resources after release of some resources",resource.getAvailable(), expected_available); + + resources_to_release = (resources_to_request - resources_to_release); + ensure("Release remaining resources",resource.release(resources_to_release)); + + ensure_equals("Verify available resources after release of remaining resources",resource.getAvailable(), total); + } + + template<> template<> + void LLScriptResourceTestObject::test<3>() + { + LLScriptResource resource; + + U32 total = 42; + resource.setTotal(total); + + ensure("Request all resources",resource.request(total)); + + U32 low_total = 10; + ensure("Release all resources",resource.release(total)); + ensure_equals("Verify all resources available after releasing",resource.getAvailable(),total); + + resource.setTotal(low_total); + ensure_equals("Verify low total resources are available after set",resource.getAvailable(),low_total); + } + + + template<> template<> + void LLScriptResourceTestObject::test<4>() + { + S32 big_resource_total = 100; + S32 small_resource_total = 10; + LLScriptResourcePool big_pool; + big_pool.getPublicURLResource().setTotal(big_resource_total); + LLScriptResourcePool small_pool; + small_pool.getPublicURLResource().setTotal(small_resource_total); + + TestConsumer consumer; + LLScriptResourcePool& initial_pool = consumer.getScriptResourcePool(); + ensure("Initial resource pool is 'null'.", (&initial_pool == &LLScriptResourcePool::null)); + + consumer.switchScriptResourcePools(big_pool); + LLScriptResourcePool& get_pool = consumer.getScriptResourcePool(); + ensure("Get resource that was set.", (&big_pool == &get_pool)); + + ensure_equals("No public urls in use yet.", consumer.getUsedPublicURLs(),0); + + S32 request_urls = 5; + consumer.mUsedURLs = request_urls; + consumer.getScriptResourcePool().getPublicURLResource().request(request_urls); + + ensure_equals("Available urls on big_pool is 5 less than total.", + big_pool.getPublicURLResource().getAvailable(), big_resource_total - request_urls); + + ensure("Switching from big pool to small pool", + consumer.switchScriptResourcePools(small_pool)); + + ensure_equals("All resources available to big pool again", + big_pool.getPublicURLResource().getAvailable(), big_resource_total); + + ensure_equals("Available urls on small pool is 5 less than total.", + small_pool.getPublicURLResource().getAvailable(), small_resource_total - request_urls); + + ensure("Switching from small pool to big pool", + consumer.switchScriptResourcePools(big_pool)); + + consumer.getScriptResourcePool().getPublicURLResource().release(request_urls); + + request_urls = 50; // Too many for the small_pool + + consumer.mUsedURLs = request_urls; + consumer.getScriptResourcePool().getPublicURLResource().request(request_urls); + + // Verify big pool has them + ensure_equals("Available urls on big pool is 50 less than total.", + big_pool.getPublicURLResource().getAvailable(), big_resource_total - request_urls); + + // Verify can't switch to small_pool + ensure("Switching to small pool with too many resources", + !consumer.switchScriptResourcePools(small_pool)); + + // Verify big pool still accounting for used resources + ensure_equals("Available urls on big_pool is still 50 less than total.", + big_pool.getPublicURLResource().getAvailable(), big_resource_total - request_urls); + + // Verify small pool still has all resources available. + ensure_equals("All resources in small pool are still available.", + small_pool.getPublicURLResource().getAvailable(), small_resource_total); + } +} |