Imported existing code

indra/test/llscriptresource_tut.cpp

@@ -0,0 +1,204 @@
+/** 
+ * @file llscriptresource_tut.cpp
+ * @brief Test LLScriptResource
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-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$
+ */
+
+//#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);
+	}
+}