t_util.java

derby database source code.good for you.

/*

   Derby - Class org.apache.derbyTesting.unitTests.store.T_Util

   Copyright 1997, 2005 The Apache Software Foundation or its licensors, as applicable.

   Licensed 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.store;

import org.apache.derby.iapi.store.raw.*;

import org.apache.derby.iapi.services.io.FormatableBitSet;

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

// impl imports are the preferred way to create unit tests.
import org.apache.derbyTesting.unitTests.harness.T_MultiThreadedIterations;
import org.apache.derbyTesting.unitTests.harness.T_Fail;

import org.apache.derby.iapi.services.context.ContextService;
import org.apache.derby.iapi.services.context.ContextManager;
import org.apache.derby.iapi.services.locks.*;
import org.apache.derby.iapi.services.sanity.SanityManager;

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

import org.apache.derby.iapi.store.access.AccessFactoryGlobals;
import org.apache.derby.iapi.store.access.Qualifier;

import org.apache.derby.iapi.store.access.conglomerate.LogicalUndo;

import org.apache.derby.iapi.types.DataValueDescriptor;


import org.apache.derby.iapi.reference.Attribute;
import org.apache.derby.iapi.services.property.PropertyUtil;
import org.apache.derby.iapi.error.ExceptionSeverity;
import java.io.*;
import java.util.Properties;
import org.apache.derby.iapi.types.SQLChar;


/*
  Utility class to help test raw store functionality.  

  If you write a raw store unit test, be that a protocol test or an
  implementation test, and find youself needing to do certain operations over
  and over again, chances are that functionality is either in here or should be
  added.  This class is here entirely for the convenience of people writing
  unit tests for the RawStore.
*/
public class T_Util
{ 

	RawStoreFactory	rsFactory;
	LockFactory  lFactory;
	ContextService csFactory;

	private int		openContainerMode;	// mode flags used in openContainer

	public T_Util(RawStoreFactory rsf, LockFactory lf, 
				  ContextService csf)
	{
		rsFactory = rsf;
		lFactory = lf;
		csFactory = csf;

		openContainerMode = 0; // logged by default
	}

	public void setOpenMode(int newMode) {
		openContainerMode = newMode;
	}

	/*
	 * function that checks for a condition, throws T_Fail exception if the condition
	 * is not met.
	 */

	/*
	 * check that transaction does not hold any lock
	 */
	public void t_checkNullLockCount(Transaction t) throws T_Fail {
		if (lFactory.areLocksHeld(t))
			throw T_Fail.testFailMsg("Previous action did not clean up all locks.");
	}

	/*
	 * check that page number on the page matches the input page number
	 */
	public static void t_checkPageNumber(Page page, long pageNumber) throws T_Fail {
		if (page.getPageNumber() != pageNumber)
			throw T_Fail.testFailMsg("page number expected to be " + pageNumber + ", is " +
				page.getPageNumber());
	}

	/*
	 * check that the number of record on the page matches input.  
	 * @param page the page in question
	 * @param count the total number of record - this include deleted as well as non-deleted
	 * @param nonDeleted the number of non-deleted record
	 */
	public static void t_checkRecordCount(Page page, int count, int nonDeleted) throws T_Fail, StandardException {
		if (page.recordCount() != count)
			throw T_Fail.testFailMsg("recordCount() expected to be " + count + ", is " + page.recordCount());

		if (page.nonDeletedRecordCount() != nonDeleted)
			throw T_Fail.testFailMsg("nonDeletedRecordCount() expected to be " + nonDeleted + ", is " + page.nonDeletedRecordCount());
	}

	/*
	 * check the number of fields in the slot
	 */
	public static void t_checkFieldCount(Page page, int slot, int count) throws T_Fail, StandardException {
		if (page.fetchNumFieldsAtSlot(slot) != count)
			throw T_Fail.testFailMsg("number of fields at slot " + slot + " expected to be " + count
									 + ", is " + page.fetchNumFieldsAtSlot(slot));
	}

	/**
		Fetch a record that is expected to exist using a record handle.
		The record has a T_RawStoreRow of 1 column and this column as value as
		specified by data, which could be null.

		Calls recordExists() before fetch to ensure that the record
		is there.

		@param page the page in question
		@param rh the record handle
		@param data the string value that is expected in the row

		@exception T_Fail Implementation failed expectation
		@exception StandardException Unexpected exception from the implementation

		@see Page#recordExists
		@see Page#fetch
	*/
	public static void t_checkFetch(Page page, RecordHandle rh, String data, int stringLen)
		throws T_Fail, StandardException {

		t_checkFetch(page, rh, T_Util.getStringFromData(data, stringLen));
	}
	
	public static void t_checkFetch(Page page, RecordHandle rh, String data)
		throws T_Fail, StandardException {

		if (!page.recordExists(rh, false))
			throw T_Fail.testFailMsg("Record does not exist");

		T_RawStoreRow readRow = new T_RawStoreRow((String) null);

		int slot = page.getSlotNumber(rh);

		RecordHandle rhf = 
            page.fetchFromSlot(
                rh, slot, readRow.getRow(), 
                (FetchDescriptor) null,
                false);

		if (rhf == null)
			throw T_Fail.testFailMsg("Failed to read record");

		if ((data == null) || readRow.getStorableColumn(0).isNull()) {

			if ((data == null) && readRow.getStorableColumn(0).isNull())
				return;

			throw T_Fail.testFailMsg("Record's value incorrect");
		}

		if (!readRow.toString().equals(data))
			throw T_Fail.testFailMsg("Record's value incorrect, expected :" + data + ": - got :" + readRow.toString());
	}

	/**
		Fetch a record from a container that is expected to exist using a record handle.
		Calls recordExists() before fetch to ensure that the record
		is there.

		@exception T_Fail Implementation failed expectation
		@exception StandardException Unexpected exception from the implementation

		@see Page#recordExists
		@see Page#fetch
	*/
	public void t_checkFetch(ContainerHandle c, RecordHandle rh, String data)
		throws T_Fail, StandardException {

		Page page = t_getPage(c, rh.getPageNumber());

		try
		{
			t_checkFetch(page, rh, data);
		}
		finally
		{
			page.unlatch();
		}
	}

	/**
		Check to make sure record is NOT there

		@exception T_Fail Implementation failed expectation
		@exception StandardException Unexpected exception from the implementation
	 */
	public void t_checkFetchFail(ContainerHandle c, RecordHandle rh)
		throws T_Fail, StandardException 
	{
		Page page = t_getPage(c, rh.getPageNumber());

		try
		{
			if (page.recordExists(rh, true))
				throw T_Fail.testFailMsg("Record Exists");
		}
		finally
		{
			page.unlatch();
		}
	}

	/**
		Fetch a deleted record from a container using a record handle.

		@exception T_Fail Implementation failed expectation
		@exception StandardException Unexpected exception from the implementation

		@see Page#recordExists
		@see Page#fetch
	*/
	public void t_checkFetchDeleted(ContainerHandle c, RecordHandle rh, 
									String data)
		throws T_Fail, StandardException 
	{
		Page p = t_getPage(c, rh.getPageNumber());
		if (p == null)
			throw T_Fail.testFailMsg("Page not found " + rh);

		T_RawStoreRow readRow = new T_RawStoreRow((String) null);

		try
		{
			int slot = p.getSlotNumber(rh);
			if (p.fetchFromSlot(
                    rh, slot, readRow.getRow(), 
                    (FetchDescriptor) null,
                    false) != null)
            {
				throw T_Fail.testFailMsg(
                    "Record at slot " + slot + " not deleted");
            }
		}
		finally
		{
			p.unlatch();
		}
	}


	/*
		Fetch a record that is expected to exist using a record handle.
		The record contains the values in the passed in row, which is a
		T_RawStoreRow.  A T_RawStoreRow of the same number of columns will be made and fetched
		from the page and compared with the passed in row.

	*/
	public static void t_checkFetch(Page page, RecordHandle rh, T_RawStoreRow row)
		throws T_Fail, StandardException 
	{
		if (!page.recordExists(rh, false))
			throw T_Fail.testFailMsg("Record does not exist");

		// try to fetch the same number of columns as the passed in row
		int ncol = row.nColumns();
		T_RawStoreRow readRow = new T_RawStoreRow(ncol);
		for (int i = 0; i < ncol; i++)
			readRow.setColumn(i, (String) null);

		RecordHandle rhf = page.fetch(rh, readRow.getRow(), (FormatableBitSet) null, false);
		if (rhf == null)
			throw T_Fail.testFailMsg("Failed to read record");
		if (!readRow.toString().equals(row.toString()))
			throw T_Fail.testFailMsg("Record's value incorrect, expected :" +
									 row.toString() + ": - got :" + readRow.toString());
	}


	/*
	    Using sparse row representation:
		Fetch a column of a record that is expected to exist, using a record 
		handle and a FormatableBitSet object.
		Check that column colNum has value data.
	*/
	public static void t_checkFetchCol(Page page, RecordHandle rh, int colNum,
									   int numCols, String data)
		throws T_Fail, StandardException 
	{
		if (!page.recordExists(rh, false))
			throw T_Fail.testFailMsg("Record does not exist");

		T_RawStoreRow readRow = new T_RawStoreRow(numCols);
		for (int i = 0; i < numCols; i++)
			readRow.setColumn(i, (String) null);
		FormatableBitSet colList = new FormatableBitSet(numCols);
		colList.set(colNum);

		RecordHandle rhf = page.fetch(rh, readRow.getRow(), colList, false);
		if (rhf == null)
			throw T_Fail.testFailMsg("Failed to read record");
		String col = readRow.getStorableColumn(colNum).toString();
		if (!col.equals(data))
			throw T_Fail.testFailMsg("Record's value for column " + colNum +
									 " incorrect, expected :" + data +
									 ": - got :" + readRow.toString());
	}


	/*
	 * the following is a sequence of fetches, fetching the first row, fetching
	 * the next and previous rows, and fetching the last row in the page.
	 *
	 * The row is assumed to be a T_RawStoreRow with 1 column, which value is the
	 * string specified in data.
	 */

	/*
	 * fetch and check the first row in the page.  
	 * Return the first row's recordHandle. 
	 */
	public static RecordHandle t_checkFetchFirst(Page page, String data)
		throws T_Fail, StandardException {
		T_RawStoreRow readRow = new T_RawStoreRow((String) null);

        int slot = 0;
        while (page.isDeletedAtSlot(slot))
        {
            slot++;
        }

		RecordHandle rhf = 
            page.fetchFromSlot(
                (RecordHandle) null, slot, 
                readRow.getRow(), 
                (FetchDescriptor) null,
                false);

		if (rhf == null)
			throw T_Fail.testFailMsg("Failed to read record");
		if (!readRow.toString().equals(data))
			throw T_Fail.testFailMsg("Record's value incorrect, expected :" + data + ": - got :" + readRow.toString());

		return rhf;
	}

	/*
	 * Fetch and check the next (next to rh) row in the page.
	 * Return the next row's recordHandle
	 */
	public static RecordHandle t_checkFetchNext(Page page, RecordHandle rh, String data)
		throws T_Fail, StandardException {

		if (!page.recordExists(rh, false))
			throw T_Fail.testFailMsg("Record does not exist");

		T_RawStoreRow readRow = new T_RawStoreRow((String) null);

        int slot = page.getSlotNumber(rh) + 1;
        while (page.isDeletedAtSlot(slot))
        {
            slot++;
        }

		RecordHandle rhf = 
            page.fetchFromSlot(
                (RecordHandle) null, 
                slot,
                readRow.getRow(), 
                (FetchDescriptor) null,
                false);

		if (rhf == null)
			throw T_Fail.testFailMsg("Failed to read record");
		if (!readRow.toString().equals(data))
			throw T_Fail.testFailMsg("Record's value incorrect, expected :" + data + ": - got :" + readRow.toString());

		return rhf;
	}
	
	/*
	 * Fetch and check the previous (previous to rh) row in the page.
	 * Return the previous row's recordHandle
	 */
	public static RecordHandle t_checkFetchPrevious(Page page, RecordHandle rh, String data)
		throws T_Fail, StandardException {

		if (!page.recordExists(rh, false))
			throw T_Fail.testFailMsg("Record does not exist");

		T_RawStoreRow readRow = new T_RawStoreRow((String) null);

        int slot = page.getSlotNumber(rh) - 1;

        while (page.isDeletedAtSlot(slot) && slot >= 0)
        {
            slot--;
        }

        if (slot == -1)
            return(null);


		RecordHandle rhf = 
            page.fetchFromSlot(
                (RecordHandle) null, 
                slot,
                readRow.getRow(), 
                (FetchDescriptor) null,
                false);

		if (rhf == null)
			throw T_Fail.testFailMsg("Failed to read record");
		if (!readRow.toString().equals(data))
			throw T_Fail.testFailMsg("Record's value incorrect, expected :" + data + ": - got :" + readRow.toString());

		return rhf;
	}

	/*
	 * Fetch and check the last row in the page.
	 * Return the last row's recordHandle
	 */
	public static RecordHandle t_checkFetchLast(Page page, String data)
		throws T_Fail, StandardException {
		T_RawStoreRow readRow = new T_RawStoreRow((String) null);

        int slot = page.recordCount() - 1;
        while (page.isDeletedAtSlot(slot) && slot >= 0)
        {
            slot--;
        }

        if (slot == -1)
            return(null);

		RecordHandle rhf = 
            page.fetchFromSlot(
                (RecordHandle) null, 
                slot,
                readRow.getRow(),
                (FetchDescriptor) null,
                false);

		if (rhf == null)
			throw T_Fail.testFailMsg("Failed to read record");
		if (!readRow.toString().equals(data))
			throw T_Fail.testFailMsg("Record's value incorrect, expected :" + data + ": - got :" + readRow.toString());

		return rhf;
	}


	/*
	 * Fetch and check the slot on the page.  
	 *
	 * The slot number is NOT a stable reference once the page is unlatched,
	 * this check is only valid if you know the page has not been unlatched
	 * since you put the row in, or you know nobody has touched the page since
	 * you determined the slot number
	 *