/** 
 * @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);
	}
}