/*

   Derby - Class org.apache.derbyTesting.unitTests.services.T_LockFactory

   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

 */

package org.apache.derbyTesting.unitTests.services;

import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;

import org.apache.derbyTesting.unitTests.harness.T_MultiIterations;
import org.apache.derbyTesting.unitTests.harness.T_Fail;

import org.apache.derby.iapi.services.locks.*;

import org.apache.derby.iapi.services.monitor.Monitor;

import org.apache.derby.iapi.reference.SQLState;

import org.apache.derby.iapi.error.StandardException;

/**
	Protocol unit test for the LockManager.

	@see LockFactory
	@see org.apache.derbyTesting.unitTests.harness.UnitTest
*/

public class T_LockFactory extends T_MultiIterations
{
	protected final static int ITERATIONS = 100;	// iterations of multi-user tests

	protected LockFactory	lf;

	public T_LockFactory() {
		super();
	}

	/*
	** The tests
	*/

	protected String getModuleToTestProtocolName() {

		return org.apache.derby.iapi.reference.Module.LockFactory;
	}

	/**
		Run all the tests, each test that starts with 'S' is a single user
		test, each test that starts with 'M' is a multi-user test.

		@exception T_Fail The test failed in some way.
	*/
	protected  void setupTest() throws T_Fail {

		try {
			lf = (LockFactory) startSystemModule(getModuleToTestProtocolName());
		} catch (StandardException mse) {
			throw T_Fail.exceptionFail(mse);
		}
		if (lf == null) {
			throw T_Fail.testFailMsg(getModuleToTestProtocolName() + " module not started.");
		}
	}

	/**
		Run once per-iteration to run the actual test.
		@exception T_Fail the test failed in some way.
	*/
	protected void runTestSet() throws T_Fail {

		// Set up the expected error handling
		try {
			
			S001();
			S002();
			S003();
			S004();
			S005();
			S007();

			M001();
			M002();
			M003();
			M004();
			

		} catch (StandardException se) {

			throw T_Fail.exceptionFail(se);

		}
	}

	/*
	** Test functions
	*/

	/**
		Single user API test 001.

		Lock an single object in a single group with all lock methods and
		then unlock the object with all unlock methods.

		@exception StandardException	An exception thrown by a method of LockFactory
		@exception T_Fail	Some behaviour of the LockFactory is incorrect
	*/
	void S001() throws StandardException, T_Fail {

		CompatibilitySpace cs = lf.createCompatibilitySpace(null);
		Object g0 = new Object();	// create an object for a lock group
		Lockable l0 = new T_L1();		// simple lockable

		int count;
		
		// check we have no locks held
		checkLockCount(cs, 0);

		// lock and unlock specifically (no timeout)
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		checkLockCount(cs, 1);
		count = lf.unlock(cs, g0, l0, null);
		if (count != 1)
			throw T_Fail.testFailMsg("invalid unlock count, expected 1, got " + count);

		// check we have no locks held
		checkLockCount(cs, 0);

		// lock twice and unlock all ...
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		checkLockCount(cs, 2);
		lf.unlock(cs, g0, l0, null);
		lf.unlock(cs, g0, l0, null);

		// check we have no locks held
		checkLockCount(cs, 0);

		// lock three times and unlock by group
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		checkLockCount(cs, 3);
		lf.unlockGroup(cs, g0);

		// check we have no locks held
		checkLockCount(cs, 0);


		// lock three times and unlock explicitly
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		checkLockCount(cs, 3);

		lf.unlock(cs, g0, l0, null);
		checkLockCount(cs, 2);

		lf.unlock(cs, g0, l0, null);
		checkLockCount(cs, 1);

		lf.unlock(cs, g0, l0, null);
		checkLockCount(cs, 0);

		// lock and unlock specifically with timeout
		lf.lockObject(cs, g0, l0, null, 1000 /*ms*/);
		checkLockCount(cs, 1);
		count = lf.unlock(cs, g0, l0, null);
		if (count != 1)
			throw T_Fail.testFailMsg("invalid unlock count, expected 1, got " + count);

		PASS("S001");
	}

	/**
		Single user API test 002.

		Lock an object in different groups and check unlocks
		apply to a single group.

		@exception StandardException	An exception thrown by a method of LockFactory
		@exception T_Fail	Some behaviour of the LockFactory is incorrect
	*/

	void S002() throws StandardException, T_Fail {

		CompatibilitySpace cs = lf.createCompatibilitySpace(null);
		Object g0 = new Object();	// create an object for a lock group
		Object g1 = new Object();
		Lockable l0 = new T_L1();		// simple lockable

		int count;
		
		// check we have no locks held
		checkLockCount(cs, 0);

		// lock object in two groups and unlock specifically
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g1, l0, null, C_LockFactory.WAIT_FOREVER);
		checkLockGroupCount(cs, g0, 1);
		checkLockGroupCount(cs, g1, 1);
		checkLockCount(cs, 2);

		count = lf.unlock(cs, g0, l0, null);
		if (count != 1)
			throw T_Fail.testFailMsg("invalid unlock count, expected 1, got " + count);
		checkLockGroupCount(cs, g0, 0);
		checkLockGroupCount(cs, g1, 1);
		checkLockCount(cs, 1);

		count = lf.unlock(cs, g1, l0, null);
		if (count != 1)
			throw T_Fail.testFailMsg("invalid unlock count, expected 1, got " + count);
		checkLockGroupCount(cs, g0, 0);
		checkLockGroupCount(cs, g1, 0);


		// check we have no locks held
		checkLockCount(cs, 0);

		// lock object in two groups and unlock by group
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g1, l0, null, C_LockFactory.WAIT_FOREVER);
		checkLockCount(cs, 2);

		lf.unlockGroup(cs, g1);
		checkLockGroupCount(cs, g0, 1);
		checkLockGroupCount(cs, g1, 0);
		checkLockCount(cs, 1);

		lf.unlockGroup(cs, g0);
		checkLockGroupCount(cs, g0, 0);
		checkLockGroupCount(cs, g1, 0);

		// check we have no locks held
		checkLockCount(cs, 0);

		PASS("S002");
	}

	/**
		Single user API test 003.

		Lock multiple objects in different groups and check unlocks
		apply to a single group.

		@exception StandardException	An exception thrown by a method of LockFactory
		@exception T_Fail	Some behaviour of the LockFactory is incorrect

	*/

	void S003() throws StandardException, T_Fail {

		CompatibilitySpace cs = lf.createCompatibilitySpace(null);
		Object g0 = new Object();	// create an object for a lock group
		Object g1 = new Object();
		Lockable l0 = new T_L1();		// simple lockable
		Lockable l1 = new T_L1();
		Lockable l2 = new T_L1();

		int count;
		
		// check we have no locks held
		checkLockCount(cs, 0);

		// lock l0 object in two groups and l1,l2 in group l1
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g1, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g1, l1, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g1, l2, null, C_LockFactory.WAIT_FOREVER);

		checkLockGroupCount(cs, g0, 1);
		checkLockGroupCount(cs, g1, 3);
		checkLockCount(cs, 4);

		// quick check to see that no one is blocked
		if (lf.anyoneBlocked())
			throw T_Fail.testFailMsg("anyoneBlocked() returned true on a set of private locks");

		lf.unlock(cs, g1, l1, null);
		checkLockGroupCount(cs, g0, 1);
		checkLockGroupCount(cs, g1, 2);
		checkLockCount(cs, 3);

		lf.unlockGroup(cs, g1);
		checkLockGroupCount(cs, g0, 1);
		checkLockGroupCount(cs, g1, 0);
		checkLockCount(cs, 1);

		lf.unlockGroup(cs, g0);
		checkLockGroupCount(cs, g0, 0);
		checkLockGroupCount(cs, g1, 0);

		// check we have no locks held
		checkLockCount(cs, 0);

		PASS("S003");
	}

	/**
		Single user API test 004.

		Lock multiple objects in different groups and transfer
		locks between groups.

		@exception StandardException	An exception thrown by a method of LockFactory
		@exception T_Fail	Some behaviour of the LockFactory is incorrect
	*/

	void S004() throws StandardException, T_Fail {

		CompatibilitySpace cs = lf.createCompatibilitySpace(null);
		Object g0 = new Object();	// create an object for a lock group
		Object g1 = new Object();
		Object g2 = new Object();
		Lockable l0 = new T_L1();		// simple lockable
		Lockable l1 = new T_L1();
		Lockable l2 = new T_L1();

		int count = 0;

		// check we have no locks held
		checkLockCount(cs, 0);

		// lock l0 object in two groups and l1,l2 in group l1
		lf.lockObject(cs, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g1, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g1, l1, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs, g1, l2, null, C_LockFactory.WAIT_FOREVER);

		checkLockGroupCount(cs, g0, 1);
		checkLockGroupCount(cs, g1, 3);
		checkLockCount(cs, 4);

		lf.transfer(cs, g0, g1);
		checkLockGroupCount(cs, g0, 0);
		checkLockGroupCount(cs, g1, 4);
		checkLockCount(cs, 4);

		// transfer an empty to a non-existent one
		lf.transfer(cs, g0, g2);
		checkLockGroupCount(cs, g0, 0);
		checkLockGroupCount(cs, g1, 4);
		checkLockGroupCount(cs, g2, 0);
		checkLockCount(cs, 4);
		
		lf.lockObject(cs, g2, l0, null, C_LockFactory.WAIT_FOREVER);
		checkLockGroupCount(cs, g2, 1);
		checkLockCount(cs, 5);

		lf.transfer(cs, g1, g2);
		checkLockGroupCount(cs, g1, 0);
		checkLockGroupCount(cs, g2, 5);
		checkLockCount(cs, 5);

		lf.transfer(cs, g2, g1);
		checkLockGroupCount(cs, g1, 5);
		checkLockGroupCount(cs, g2, 0);
		checkLockCount(cs, 5);


		lf.unlockGroup(cs, g2);
		checkLockGroupCount(cs, g1, 5);
		checkLockGroupCount(cs, g2, 0);
		checkLockCount(cs, 5);

		lf.unlockGroup(cs, g1);
		checkLockGroupCount(cs, g1, 0);
		checkLockGroupCount(cs, g2, 0);

		// check we have no locks held
		checkLockCount(cs, 0);

		PASS("S004");
	}

	/**
		Single user API test 005.

		Create two compatability spaces and ensure that locks
		block each other out.

		@exception StandardException	An exception thrown by a method of LockFactory
		@exception T_Fail	Some behaviour of the LockFactory is incorrect
	*/
	void S005() throws StandardException, T_Fail {

		CompatibilitySpace cs0 = lf.createCompatibilitySpace(null);
		CompatibilitySpace cs1 = lf.createCompatibilitySpace(null);

		Object g0 = new Object();	// create an object for a lock group
		Object g1 = new Object();	// create an object for a lock group
		Lockable l0 = new T_L1();
		Lockable l1 = new T_L1();
		Lockable l2 = new T_L1();

		int count;

		// check we have no locks held
		checkLockCount(cs0, 0);
		checkLockCount(cs1, 0);

		lf.lockObject(cs0, g0, l0, null, C_LockFactory.WAIT_FOREVER);
		lf.lockObject(cs1, g1, l1, null, C_LockFactory.WAIT_FOREVER);
		checkLockCount(cs0, 1);
		checkLockCount(cs1, 1);

		lf.lockObject(cs0, g0, l2, null, C_LockFactory.WAIT_FOREVER);
		checkLockCount(cs0, 2);
		checkLockCount(cs1, 1);

		// now attempt to lock l2 in cs1 with a timeout, should fail
		try {
			lf.lockObject(cs1, g1, l2, null, 200 /* ms */);
			throw T_Fail.testFailMsg("lock succeeded on already locked object");
		}
		catch (StandardException lfe) {
			// we are expecting the timout exception, anything else is an error
			if (!lfe.getMessageId().equals(SQLState.LOCK_TIMEOUT)) {
				throw lfe;
			}
			checkLockCount(cs0, 2);
			checkLockCount(cs1, 1);

		}

		// now unlock the object, and re-attempt the lock
		lf.unlock(cs0, g0, l2, null);
		checkLockCount(cs0, 1);
		checkLockCount(cs1, 1);
		lf.lockObject(cs1, g1, l2, null, C_LockFactory.WAIT_FOREVER);
		checkLockCount(cs0, 1);
		checkLockCount(cs1, 2);

		lf.unlockGroup(cs0, g0);
		lf.unlockGroup(cs1, g1);
		checkLockCount(cs0, 0);
		checkLockCount(cs1, 0);

		PASS("S005");



	}	


	/**
		Single user API test 007.

		Tests on groups and compatibility spaces
		never seen by the lock manager.
		

		@exception StandardException	An exception thrown by a method of LockFactory
		@exception T_Fail	Some behaviour of the LockFactory is incorrect
	*/
	void S007() throws StandardException, T_Fail {

		CompatibilitySpace cs = lf.createCompatibilitySpace(null);
		Object g0 = new Object();	// create an object for a lock group
		Object g1 = new Object();	// create an object for a lock group
		Lockable l0 = new T_L1();

		int count;

		// check we have no locks held
		checkLockCount(cs, 0);
		checkLockGroupCount(cs, g0, 0);

		lf.unlockGroup(cs, g0);
		lf.unlockGroup(cs, cs);
		lf.unlock(cs, g0, l0, null);

		lf.transfer(cs, g0, g1);
		lf.transfer(cs, g1, g0);

		if (lf.anyoneBlocked())
			throw T_Fail.testFailMsg("anyoneBlocked() returned true on an empty space");

		// check we have no locks held
		checkLockCount(cs, 0);
		checkLockGroupCount(cs, g0, 0);
		checkLockGroupCount(cs, g1, 0);

		PASS("S007");
	}

	/*
	** Multi-user tests.
	*/

	/**
		Multi-user test 001.

		Create two lockable objects and pass them off to two threads.
		Each thread will run lock the first object, set its value then lock
		the second object and set its value, yield and then release the lock
		on one and then on two. Various checks are made to ensure the
		values are as expected.

		@exception StandardException	An exception thrown by a method of LockFactory
		@exception T_Fail	Some behaviour of the LockFactory is incorrect
	*/

	void M001() throws StandardException, T_Fail {

		Lockable[] locks = new T_L1[2];
		locks[0] = new T_L1();
		locks[1] = new T_L1();

		T_User u1 = new T_User(1, lf, locks, ITERATIONS, 10 * ITERATIONS);
		T_User u2 = new T_User(1, lf, locks, ITERATIONS, 20 * ITERATIONS);
		Thread t1 = new Thread(u1);
		Thread t2 = new Thread(u2);

		t1.start();
		t2.start();

		try {
			t1.join();
			t2.join();
		} catch (InterruptedException ie) {
			throw T_Fail.exceptionFail(ie);
		}

		if (u1.error != null)
			throw T_Fail.exceptionFail(u1.error);
		if (u2.error != null)
			throw T_Fail.exceptionFail(u2.error);

		PASS("M001");
	}
	

	/**
		Multi-user test 002

		Create a single lockable and have three threads lock it, yield and
		then release it. The single lockable can only have one locker.

		@exception StandardException	An exception thrown by a method of LockFactory
		@exception T_Fail	Some behaviour of the LockFactory is incorrect
	*/

		
	void M002() throws StandardException, T_Fail {

		Lockable[] locks = new T_L1[1];
		locks[0] = new T_L1();

		T_User u1 = new T_User(2, lf, locks, ITERATIONS, 10 * ITERATIONS);
		T_User u2 = new T_User(2, lf, locks, ITERATIONS, 20 * ITERATIONS);
		T_User u3 = new T_User(2, lf, locks, ITERATIONS, 30 * ITERATIONS);
		Thread t1 = new Thread(u1);
		Thread t2 = new Thread(u2);
		Thread t3 = new Thread(u3);

		t1.start();
		t2.start();
		t3.start();

		try {
			t1.join();
			t2.join();
			t3.join();
		} catch (InterruptedException ie) {
			throw T_Fail.exceptionFail(ie);
		}

		if (u1.error != null)
			throw T_Fail.exceptionFail(u1.error);
		if (u2.error != null)
			throw T_Fail.exceptionFail(u2.error);
		if (u3.error != null)
			throw T_Fail.exceptionFail(u3.error);


		PASS("M002");
	}
	/**
		Multi-user test 003

		Create a single lockable and have three threads lock it, yield and
		then release it. The single lockable is a semaphore that can have two lockers.

		@exception StandardException	An exception thrown by a method of LockFactory
		@exception T_Fail	Some behaviour of the LockFactory is incorrect
	*/

		
	void M003() throws StandardException, T_Fail {

		Lockable[] locks = new Lockable[1];
		locks[0] = new T_L2(2);

		T_User u1 = new T_User(3, lf, locks, ITERATIONS, 0);
		T_User u2 = new T_User(3, lf, locks, ITERATIONS, 0);
		T_User u3 = new T_User(3, lf, locks, ITERATIONS, 0);
		Thread t1 = new Thread(u1);
		Thread t2 = new Thread(u2);
		Thread t3 = new Thread(u3);

		t1.start();
		t2.start();
		t3.start();

		try {
			t1.join();
			t2.join();
			t3.join();
		} catch (InterruptedException ie) {
			throw T_Fail.exceptionFail(ie);
		}

		if (u1.error != null)
			throw T_Fail.exceptionFail(u1.error);
		if (u2.error != null)
			throw T_Fail.exceptionFail(u2.error);
		if (u3.error != null)
			throw T_Fail.exceptionFail(u3.error);


		PASS("M003");
	}
	/**
		Multi-user test 004

		As M003 but each thread will lock the object twice, to ensure that
		lock manager grantes the lock when the compatability space and qualifier
		match.

		@exception StandardException	An exception thrown by a method of LockFactory
		@exception T_Fail	Some behaviour of the LockFactory is incorrect
	*/

		
	void M004() throws StandardException, T_Fail {

		Lockable[] locks = new Lockable[1];
		locks[0] = new T_L2(2);

		T_User u1 = new T_User(4, lf, locks, ITERATIONS, 0);
		T_User u2 = new T_User(4, lf, locks, ITERATIONS, 0);
		T_User u3 = new T_User(4, lf, locks, ITERATIONS, 0);
		Thread t1 = new Thread(u1);
		Thread t2 = new Thread(u2);
		Thread t3 = new Thread(u3);

		t1.start();
		t2.start();
		t3.start();

		try {
			t1.join();
			t2.join();
			t3.join();
		} catch (InterruptedException ie) {
			throw  T_Fail.exceptionFail(ie);
		}

		if (u1.error != null)
			throw  T_Fail.exceptionFail(u1.error);
		if (u2.error != null)
			throw T_Fail.exceptionFail(u2.error);
		if (u3.error != null)
			throw T_Fail.exceptionFail(u3.error);


		PASS("M004");
	}



	/*
	** Utility functions
	*/

	/**
		Check to see if the total number of locks we have is as expected.

		@exception T_Fail	Number of locks is not as expected.
	*/
	void checkLockCount(CompatibilitySpace cs, int expected) throws T_Fail {
		boolean expect = expected != 0;
		boolean got = lf.areLocksHeld(cs);
		if (got != expect)
			throw T_Fail.testFailMsg("Expected lock count (" + expect + "), got (" + got + ")");
	}

	/**
		Check to see if the number of locks in a group we have is as expected.

		@exception T_Fail	Number of locks is not as expected.
	*/

	void checkLockGroupCount(CompatibilitySpace cs, Object group, int expected)
			throws T_Fail {
		boolean expect = expected != 0;
		boolean got = lf.areLocksHeld(cs, group);
		if (got != expect)
			throw T_Fail.testFailMsg("Expected lock count (" + expect + "), got (" + got + ")");
	}

    
    /**
     * Privileged startup. Must be private so that user code
     * can't call this entry point.
     */
    private  static  Object  startSystemModule( final String factoryInterface )
        throws StandardException
    {
        try {
            return AccessController.doPrivileged
                (
                 new PrivilegedExceptionAction<Object>()
                 {
                     public Object run()
                         throws StandardException
                     {
                         return Monitor.startSystemModule( factoryInterface );
                     }
                 }
                 );
        } catch (PrivilegedActionException pae)
        {
            throw StandardException.plainWrapException( pae );
        }
    }

}


