text:
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.getCompatibilitySpace()))
			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
	*/
	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
	*/
	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#fetchFromSlot
	*/
	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.fetchFromSlot(rh, page.getSlotNumber(rh),
											  readRow.getRow(), 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);
		FetchDescriptor desc = new FetchDescriptor(numCols, colList, null);

		RecordHandle rhf = page.fetchFromSlot(rh, page.getSlotNumber(rh),
											  readRow.getRow(), desc, 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
	 *
	 * The slot refers to a row in the page which has a T_RawStoreRow of 1 column, the
	 * column has the value of data input.
	 *
	 * @param page the page in question
	 * @param slot the slot number (see above)
	 * @param data the column value
	 * @param deleted if the row is deleted, set to true
	 * @param forUpdate If you want to lock the row for update, set forUpdate to true.
	 *
	 */
	public static void t_checkFetchBySlot(Page page, int slot,
									String data, boolean deleted,
									boolean forUpdate)
		throws T_Fail, StandardException
	{
		T_RawStoreRow readRow = new T_RawStoreRow((String) null);
		RecordHandle rh =
            page.fetchFromSlot(
                (RecordHandle) null, slot,
                readRow.getRow(),
                (FetchDescriptor) null,
                true);

		if (rh == 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());

		if (page.isDeletedAtSlot(slot) != deleted)
			throw T_Fail.testFailMsg("Record at slot " + slot + " deleted=" +
									 page.isDeletedAtSlot(slot) + ", expect " + deleted);

		// RESOLVE: check locking
	}

	/*
	 * check a column value from a 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
	 *
	 * The storable in the specified column put into the input column and it
	 * is check for the same value as the input data
	 *
	 * @param page the page in question
	 * @param slot the slot number (see above)
	 * @param fieldId the field Id on the row
	 * @param column the storable to put the column in
	 * @param forUpdate true if you want to lock the row for update
	 * @param data the expected value in the column
	 */
	public static void t_checkFetchColFromSlot(Page page,
										 int slot,
										 int fieldId,
										 DataValueDescriptor column,
										 boolean forUpdate,
										 String data,
										 int stringLen)
		 throws StandardException, T_Fail
	{
		t_checkFetchColFromSlot(page, slot, fieldId, column, forUpdate, T_Util.getStringFromData(data, stringLen));
	}

	public static void t_checkFetchColFromSlot(
    Page                page,
    int                 slot,
    int                 fieldId,
    DataValueDescriptor column,
    boolean             forUpdate,
    String              data)
		 throws StandardException, T_Fail
	{
        DataValueDescriptor[] fetch_row = new DataValueDescriptor[fieldId + 1];
        fetch_row[fieldId] = column;
        FormatableBitSet validCols = new FormatableBitSet(fieldId + 1);
        validCols.set(fieldId);

		RecordHandle rh =
			page.fetchFromSlot(
                null, slot, fetch_row,
                new FetchDescriptor(
                    fetch_row.length, validCols, (Qualifier[][]) null),
                true);

		if (rh == null)
			throw T_Fail.testFailMsg("Failed to fetch record: slot "
							 + slot + " field " + fieldId);

		// RESOLVE - how to check rh lock mode?

		if (data == null)
		{
			if (!column.isNull())
				throw T_Fail.testFailMsg("Failed to fetch null column: slot "
								 + slot + " field " + fieldId + " column is " + column);
		}
		else
		{
			if (column.isNull())
				throw T_Fail.testFailMsg("expect non null column, got null: slot "
								 + slot + " field " + fieldId);
			if (!column.toString().equals(data))
				throw T_Fail.testFailMsg("expect " + data + " got " + column.toString()
								 + ": slot " + slot + " field " + fieldId);
		}
	}

	/**
		Take an empty page and check it does actually seem to be empty.

		@exception T_Fail Unexpected behaviour from the API
		@exception StandardException Unexpected exception from the implementation
	*/
	public static void t_checkEmptyPage(Page page) throws T_Fail, StandardException {

		// check the counts
		t_checkRecordCount(page, 0, 0);

        try
        {
            page.fetchFromSlot(
                (RecordHandle) null, 0, null,
                (FetchDescriptor) null,
                false);

            throw T_Fail.testFailMsg(
                "fetchFromSlot() must throw exception on fetch from slot 0 on an empty page");
        }
        catch (StandardException se)
        {
            // expected exception.
        }

		// check we can't get a record handle. NB here we are guessing that 0
		// and RecordHandle.FIRST_RECORD_ID might be valid record identifiers,
		// nothing in the API states that they will be.  Eother way we
		// shouldn't get a valid RecordHandle back.
		if (page.getRecordHandle(0) != null)
			throw T_Fail.testFailMsg("obtained a RecordHandle for an empty page");

		if (page.getRecordHandle(RecordHandle.FIRST_RECORD_ID) != null)
			throw T_Fail.testFailMsg("obtained a RecordHandle for an empty page");

		// should be no aux object
		if (page.getAuxObject() != null)
			throw T_Fail.testFailMsg("empty page has an aux object");

		t_readOnlySlotOutOfRange(page, Page.FIRST_SLOT_NUMBER);

		if (!page.spaceForInsert())
			throw T_Fail.testFailMsg("spaceForInsert() returned false on an empty page");
	}

	/*
		Check to see the correct behaviour for read only operations
		that take a slot when the slot is out of range.
	*/
	public static void t_readOnlySlotOutOfRange(Page page, int slot) throws T_Fail, StandardException {

		try {
			page.fetchFromSlot(
                (RecordHandle) null, slot,
                new DataValueDescriptor[0],
                (FetchDescriptor) null,
                true);

			throw T_Fail.testFailMsg("fetchFromSlot succeeded on out of range slot " + slot);
		} catch (StandardException se0) {
			// Statement exception expected, throw if not a statement exception.
            if (se0.getSeverity() > ExceptionSeverity.STATEMENT_SEVERITY)
                throw se0;
		}
		try {
			page.isDeletedAtSlot(slot);
			throw T_Fail.testFailMsg("isDeletedAtSlot succeeded on out of range slot " + slot);
		} catch (StandardException se2) {
			// Statement exception expected, throw if not a statement exception.
            if (se2.getSeverity() > ExceptionSeverity.STATEMENT_SEVERITY)
                throw se2;
		}
	}

	/*
		Check to see the correct behaviour for update operations
		that take a slot when the slot is out of range.
	*/
	public static void t_updateSlotOutOfRange(Page page, int slot) throws T_Fail, StandardException {

		try {
			page.deleteAtSlot(slot, false, (LogicalUndo)null);
			throw T_Fail.testFailMsg("deleteAtSlot succeeded on out of range slot " + slot);
		} catch (StandardException se0) {
			// Statement exception expected, throw if not a statement exception.
            if (se0.getSeverity() > ExceptionSeverity.STATEMENT_SEVERITY)
                throw se0;
		}
		try {
			page.deleteAtSlot(slot, true, (LogicalUndo)null);
			throw T_Fail.testFailMsg("deleteAtSlot succeeded on out of range slot " + slot);
		} catch (StandardException se0) {
			// Statement exception expected, throw if not a statement exception.
            if (se0.getSeverity() > ExceptionSeverity.STATEMENT_SEVERITY)
                throw se0;
		}

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

		// insert at the last slot will succeed, so don't do it.
		if (page.recordCount() != slot) {
			try {
					page.insertAtSlot(slot, row.getRow(), (FormatableBitSet) null, (LogicalUndo)null,
						Page.INSERT_DEFAULT, 100);
					throw T_Fail.testFailMsg("insertAtSlot succeeded, on out of range slot " + slot);
            } catch (StandardException se0) {
                // Statement exception expected, throw if not a statement exception.
                if (se0.getSeverity() > ExceptionSeverity.STATEMENT_SEVERITY)
                    throw se0;
            }
		}

		try {
			page.updateAtSlot(slot, row.getRow(), (FormatableBitSet) null);
			throw T_Fail.testFailMsg("updateAtSlot succeeded on out of range slot " + slot);
        } catch (StandardException se0) {
            // Statement exception expected, throw if not a statement exception.
            if (se0.getSeverity() > ExceptionSeverity.STATEMENT_SEVERITY)
                throw se0;
        }
	}

	/*
	 * Save point checks
	 */

	/**
		Negative test - check that an invalid savepoint is detected.

		@exception T_Fail Unexpected behaviour from the API
		@exception StandardException Unexpected exception from the implementation
	*/
	public static void t_checkInvalidSavePoint(Transaction t, String name)
		throws T_Fail, StandardException {

		// check a non-existent save point is trapped
		try {
			t.rollbackToSavePoint(name, null);

			throw T_Fail.testFailMsg("non existent save point did not cause exception on rollbackToSavePoint");
		} catch (StandardException se) {
			// we expected this ...
		}
		try {
			t.releaseSavePoint(name, null);
			throw T_Fail.testFailMsg("non existent save point did not cause exception on releaseSavePoint");

		} catch (StandardException se) {
			// we expected this ...
		}
	}

	/*
	 * same as above, check an invalid savepoint in the given transaction
	 * context
	 */
	public void t_checkInvalidSavePoint(T_TWC ctx, String name)
		throws T_Fail, StandardException {
		csFactory.setCurrentContextManager(ctx.cm);
		try {
		t_checkInvalidSavePoint(ctx.tran, name);
		} finally {
			csFactory.resetCurrentContextManager(ctx.cm);
		}
	}

	/*
	 * function that actually do something, start, commit, abort a trasaction,
	 * get a page, insert a row, etc.
	 */

	/*
		Start a user transaction, ensures that the startTransaction method
		does not return null (which it shouldn't).
	*/
	public Transaction t_startTransaction()
		throws StandardException, T_Fail {

			Transaction t1 =
                rsFactory.startTransaction(
                    csFactory.getCurrentContextManager(),
					AccessFactoryGlobals.USER_TRANS_NAME);

			if (t1 == null)
				throw T_Fail.testFailMsg("Start a transaction");
			t_checkNullLockCount(t1);
			return t1;
	}

	/*
		Start a user transaction, ensures that the startTransaction method
		does not return null (which it shouldn't).
	*/
	public Transaction t_startGlobalTransaction(
    int     format_id,
    byte[]  global_id,
    byte[]  branch_id)
		throws StandardException, T_Fail {

			Transaction t1 =
                rsFactory.startGlobalTransaction(
                    csFactory.getCurrentContextManager(),
                    format_id, global_id, branch_id);

			if (t1 == null)
				throw T_Fail.testFailMsg("Start a transaction");
			t_checkNullLockCount(t1);
			return t1;
	}

	/*
	 * start a user transaction with its own context (T_TWC)
	 */
	public T_TWC t_startTransactionWithContext()
		throws StandardException, T_Fail
	{
		T_TWC ctx = new T_TWC(csFactory, lFactory, rsFactory);
		ctx.startUserTransaction();
		return ctx;
	}

	/*
	 * start an internal transaction
	 */
	public Transaction t_startInternalTransaction()
		throws StandardException, T_Fail {

			Transaction t1 = rsFactory.startInternalTransaction(csFactory.getCurrentContextManager());

			if (t1 == null)
				throw T_Fail.testFailMsg("Failed to start an internal transaction");
			t_checkNullLockCount(t1);
			return t1;
	}

	/*
	 * commit a transaction
	 */
	public void t_commit(Transaction t)
		throws StandardException, T_Fail {
		t.commit();
		t_checkNullLockCount(t);
	}

	/*
	 * commit a transaction with context
	 */
	public void t_commit(T_TWC ctx)
		throws StandardException, T_Fail
	{
		csFactory.setCurrentContextManager(ctx.cm);
		try {
		t_commit(ctx.tran);
		} finally {
			csFactory.resetCurrentContextManager(ctx.cm);
		}
	}

	/*
	 * close a transaction with context
	 */
	public void t_close(T_TWC ctx)
		throws StandardException, T_Fail
	{
		ctx.tran.close();
		ctx.tran = null;
		ctx.cm = null;		// no need to close a context ???
	}

	/*
	 * abort a transaction
	 */
	public void t_abort(Transaction t)
		throws StandardException, T_Fail {
		t.abort();
		t_checkNullLockCount(t);
	}

	/*
	 * abort a transaction with context
	 */
	public void t_abort(T_TWC ctx)
		throws StandardException, T_Fail
	{
		csFactory.setCurrentContextManager(ctx.cm);
		try {
		t_abort(ctx.tran);
		} finally {
			csFactory.resetCurrentContextManager(ctx.cm);
		}
	}

	/**
		Add a new container in the transaction

		@exception T_Fail Unexpected behaviour from the API
		@exception StandardException Unexpected exception from the implementation
	*/
	public long t_addContainer(Transaction t, long segmentId)
		throws StandardException, T_Fail {

		long cid =
            t.addContainer(
                segmentId, ContainerHandle.DEFAULT_ASSIGN_ID,
                ContainerHandle.MODE_DEFAULT, (Properties) null, 0);

		if (cid < 0)
			throw T_Fail.testFailMsg("add container");

		return cid;
	}

	public long t_addContainer(T_TWC ctx, long segmentId)
		throws StandardException, T_Fail
	{
		csFactory.setCurrentContextManager(ctx.cm);
		try {
		return t_addContainer(ctx.tran, segmentId);
		} finally {
			csFactory.resetCurrentContextManager(ctx.cm);
		}
	}

	/**

		Add a new container in the transaction with a specified page size

		@exception T_Fail Unexpected behaviour from the API
		@exception StandardException Unexpected exception from the implementation
	*/
	public long t_addContainer(Transaction t, long segmentId, int pageSize)
		throws StandardException, T_Fail {

		Properties tableProperties = new Properties();
		tableProperties.put(Property.PAGE_SIZE_PARAMETER, Integer.toString(pageSize));

		long cid =
            t.addContainer(
                segmentId, ContainerHandle.DEFAULT_ASSIGN_ID,
                ContainerHandle.MODE_DEFAULT, tableProperties, 0);

		if (cid < 0)
			throw T_Fail.testFailMsg("add container");

		return cid;
	}

	public long t_addContainer(T_TWC ctx, long segmentId, int pageSize)
		throws StandardException, T_Fail {

		csFactory.setCurrentContextManager(ctx.cm);
		try {
		return t_addContainer(ctx.tran, segmentId, pageSize);
		} finally {
			csFactory.resetCurrentContextManager(ctx.cm);
		}
	}

	public long t_addContainer(Transaction t, long segmentId, Properties tableProperties)
		throws StandardException, T_Fail {

		long cid =
            t.addContainer(
                segmentId, ContainerHandle.DEFAULT_ASSIGN_ID,
                ContainerHandle.MODE_DEFAULT, tableProperties, 0);

		if (cid < 0)
			throw T_Fail.testFailMsg("add container");

		return cid;
	}

	/**

		Add a new container in the transaction with specified
        pageSize, spareSpace, minimumRecordSize, and reusableRecordId

		@exception T_Fail Unexpected behaviour from the API
		@exception StandardException Unexpected exception from the implementation
	*/
	public long t_addContainer(Transaction t, long segmentId, int pageSize, int spareSpace,
			int minimumRecordSize, boolean reusableRecordId)
		throws StandardException, T_Fail {

		Properties tableProperties = new Properties();
		tableProperties.put(Property.PAGE_SIZE_PARAMETER, Integer.toString(pageSize));
		tableProperties.put(RawStoreFactory.PAGE_RESERVED_SPACE_PARAMETER, Integer.toString(spareSpace));
		tableProperties.put(RawStoreFactory.MINIMUM_RECORD_SIZE_PARAMETER, Integer.toString(minimumRecordSize));

        if (reusableRecordId) {
            tableProperties.put(RawStoreFactory.PAGE_REUSABLE_RECORD_ID, "true");
        }

		long cid =
            t.addContainer(
                segmentId, ContainerHandle.DEFAULT_ASSIGN_ID,
                ContainerHandle.MODE_DEFAULT, tableProperties, 0);

		if (cid < 0)
			throw T_Fail.testFailMsg("add container");

		return cid;
	}

	public long t_addContainer(T_TWC ctx, long segmentId, int pageSize, int spareSpace, int minimumRecordSize)
		throws StandardException, T_Fail {
		csFactory.setCurrentContextManager(ctx.cm);
		try {
		return t_addContainer(ctx.tran, segmentId, pageSize, spareSpace, minimumRecordSize, false);
		} finally {
			csFactory.resetCurrentContextManager(ctx.cm);
		}
	}

	/**
		Open a container.

		@exception T_Fail Unexpected behaviour from the API
		@exception StandardException Unexpected exception from the implementation
	*/

	public ContainerHandle t_openContainer(Transaction t, long segmentId, long containerId, boolean forUpdate)
		throws StandardException, T_Fail
	{
		ContainerKey id = new ContainerKey(segmentId, containerId);
		ContainerHandle c = t.openContainer(id,
			forUpdate ? (ContainerHandle.MODE_FORUPDATE | openContainerMode) : ContainerHandle.MODE_READONLY);
		if (c == null)
			throw T_Fail.testFailMsg("ContainerHandle failed to open: (" +
									 segmentId + "," + containerId + ")");

		return c;
	}
	public ContainerHandle t_openContainer(T_TWC ctx, long segmentId, long containerId, boolean forUpdate)
		throws StandardException, T_Fail
	{
		csFactory.setCurrentContextManager(ctx.cm);
		try {
			return t_openContainer(ctx.tran, segmentId, containerId, forUpdate);
		} finally {
			csFactory.resetCurrentContextManager(ctx.cm);
		}
	}

	/**
		Drop a container

		@exception T_Fail Unexpected behaviour from the API
		@exception StandardException Unexpected exception from the implementation
	*/
	public void t_dropContainer(Transaction t, long segmentId, long containerId)
		 throws StandardException, T_Fail
	{
		t.dropContainer(new ContainerKey(segmentId, containerId));
	}

	/**
		Get the last page in a container.
		Always returns a valid page or null if there is no page in the container.

		@exception T_Fail Unexpected behaviour from the API
		@exception StandardException Unexpected exception from the implementation
	*/
	public Page t_getLastPage(ContainerHandle c) throws T_Fail, StandardException {

		Page page = c.getFirstPage();
		if (page != null)
		{
			Page nextPage;
			while((nextPage = c.getNextPage(page.getPageNumber())) != null)
			{
				page.unlatch();
				page = nextPage;
			}
		}

		return page;
	}

	/**
		Get a specific page in a container.
		Always returns a valid page.

		@exception T_Fail Unexpected behaviour from the API
		@exception StandardException Unexpected exception from the implementation
	*/
	public Page t_getPage(ContainerHandle c, long pageNumber) throws T_Fail, StandardException {

		Page page = c.getPage(pageNumber);
		if (page == null)
			throw T_Fail.testFailMsg("fail to get page " + pageNumber + " from container " + c);

		if (page.getPageNumber() != pageNumber)
			throw T_Fail.testFailMsg("page expected to have page number " +
				pageNumber + ", has " + page.getPageNumber() + " Container " + c);

		return page;
	}

	/**
		Add a page to a container.

		@exception T_Fail Unexpected behaviour from the API
		@exception StandardException Unexpected exception from the implementation
	*/
	public Page t_addPage(ContainerHandle c) throws T_Fail, StandardException {

		Page page = c.addPage();

		if (page == null)
			throw T_Fail.testFailMsg("addPage() returned null");

		return page;
	}

	/**
		Remove a page from a container.

		@exception T_Fail Record handle returned is null.
		@exception StandardException Unexpected exception from the implementation
	*/
	public void t_removePage(ContainerHandle c, Page p) throws T_Fail, StandardException
	{
		long pnum = p.getPageNumber();
		c.removePage(p);

		// we should not be able to get this page
		Page badp = c.getPage(pnum);
		if (badp != null)
			throw T_Fail.testFailMsg("got a deallcated page back");
	}

	/**
	 * Check that it's not possible to get a page which is already latched by
	 * the same transaction.
	 *
	 * @param c a container handle
	 * @param pageNumber the page number to check
	 * @exception StandardException if an unexpected error occurs
	 * @exception T_Fail if the test fails
	 */
	public void t_checkGetLatchedPage(ContainerHandle c, long pageNumber)
			throws StandardException, T_Fail {

		try {
			Page p = c.getPage(pageNumber);
			throw T_Fail.testFailMsg("got latched page");
		} catch (StandardException se) {
            if (!"XSDAO".equals(se.getSQLState())) {
				throw se;
			}
		}
	}

	/**
		Call page.insert() and ensure that the return record handle is not null.
		This assumes the caller has called spaceForInsert.

		@exception T_Fail Record handle returned is null.
		@exception StandardException Unexpected exception from the implementation

		@see Page#insert
	*/
	public static RecordHandle t_insert(Page page, T_RawStoreRow row)
		throws T_Fail, StandardException {

		RecordHandle rh = page.insert(row.getRow(), (FormatableBitSet) null, Page.INSERT_DEFAULT, 100);

		return rh;
	}

	/**
		Call page.insert() and ensure that the return record handle is not null.
		This assumes the caller has called spaceForInsert.

		@exception T_Fail Record handle returned is null.
		@exception StandardException Unexpected exception from the implementation

		@see Page#insert
	*/
	public static RecordHandle t_insertAtSlot(Page page, int slot, T_RawStoreRow row)
		throws T_Fail, StandardException {

		RecordHandle rh = page.insertAtSlot(slot, row.getRow(), (FormatableBitSet) null,
			(LogicalUndo) null, Page.INSERT_DEFAULT, 100);

		return rh;
	}

	/**
		Call page.insert() and ensure that the return record handle is not null.
		This assumes the caller has called spaceForInsert.

		@exception T_Fail Record handle returned is null.
		@exception StandardException Unexpected exception from the implementation

		@see Page#insert
	*/
	public static RecordHandle t_insertAtSlot(Page page, int slot, T_RawStoreRow row, byte insertFlag)
		throws T_Fail, StandardException {

		RecordHandle rh = page.insertAtSlot(slot, row.getRow(), (FormatableBitSet) null,
			(LogicalUndo) null, insertFlag, 100);

		return rh;
	}

	/**
		Call page.insert() and ensure that the return record handle is not null.
		This assumes the caller has called spaceForInsert.

		@exception T_Fail Record handle returned is null.
		@exception StandardException Unexpected exception from the implementation

		@see Page#insert
	*/
	public static RecordHandle t_insertAtSlot(Page page, int slot, T_RawStoreRow row, byte insertFlag,
			int overflowThreshold) throws T_Fail, StandardException {

		RecordHandle rh = page.insertAtSlot(slot, row.getRow(), (FormatableBitSet) null,
			(LogicalUndo) null, insertFlag, overflowThreshold);

		return rh;
	}

	/**
		Insert a record on the last page, if the row doesn't fit on the
		last page create a new page and insert there.

		@exception T_Fail Record handle returned is null.
		@exception StandardException Unexpected exception from the implementation

		@see Page#insert
	*/
	public RecordHandle t_insert(ContainerHandle c, T_RawStoreRow row)
		throws T_Fail, StandardException {

		Page page = c.getPageForInsert(0);
		boolean addedPage = false;

		if (page == null)
		{
			page = t_addPage(c);
			addedPage = true;
		}
		else if (!page.spaceForInsert(row.getRow(), (FormatableBitSet) null, 100)) {
			page.unlatch();
			page = t_addPage(c);
			addedPage = true;
		}

		RecordHandle rh = t_insert(page, row);
		page.unlatch();

		if (rh == null) {
			if (addedPage)
				throw T_Fail.testFailMsg("insert returned null on an empty page");

			page = t_addPage(c);
			rh = t_insert(page, row);
			page.unlatch();
		}
		return rh;
	}

	/**
		Update a record.

		@exception T_Fail Record handle returned is null.
		@exception StandardException Unexpected exception from the implementation

		@see Page#updateAtSlot
	*/
	public void t_update(ContainerHandle c, RecordHandle rh, T_RawStoreRow row)
		 throws T_Fail, StandardException
	{
		Page page = t_getPage(c, rh.getPageNumber());
		try
		{
			int slot = page.getSlotNumber(rh);
			if (page.updateAtSlot(slot, row.getRow(), null) == null)
				throw T_Fail.testFailMsg("update failed");

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

	/**
	    Using sparse representation:
		Update a column of a record and check resulting value.

		@exception T_Fail Record handle returned is null.
		@exception StandardException Unexpected exception from the implementation

		@see Page#updateAtSlot
	*/
	public void t_checkUpdateCol(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 writeRow = new T_RawStoreRow(numCols);
		for (int i = 0; i < numCols; i++)
			writeRow.setColumn(i, (String) null);
		writeRow.setColumn(colNum, data);
		FormatableBitSet colList = new FormatableBitSet(numCols);
		colList.set(colNum);

		int slot = page.getSlotNumber(rh);
		if (page.updateAtSlot(slot, writeRow.getRow(), colList) == null)
			throw T_Fail.testFailMsg("update failed");

		t_checkFetchCol(page, rh, colNum, numCols, data);
	}

	/**
		Check to make sure a row (possibly with overflow) is of the correct length

		@exception T_Fail Record handle returned is null.
		@exception StandardException Unexpected exception from the implementation

	 */
	public void t_checkStringLengthFetch(Page page, int slot, int expectedLength) throws T_Fail, StandardException {

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

		page.fetchFromSlot(
            (RecordHandle) null, slot, rr.getRow(),
            (FetchDescriptor) null,
            true);

		String s = ((SQLChar) (rr.getStorableColumn(0))).getString();

		if ((s == null) && (expectedLength < 0))
			return;

		if ((s != null) && (expectedLength < 0))
			throw T_Fail.testFailMsg("Expected null string, fetched one of length " + s.length());

		if (s == null)
			throw T_Fail.testFailMsg("Expected string length " + expectedLength + " got null string");

		if (s.length() != expectedLength)
			throw T_Fail.testFailMsg("fetch string length incorrect expected " + expectedLength + " got " + s.length());
	}

	/**
		Lazy people's random file generator:
		Generate a random file with specified name and file size

		@exception T_Fail Record handle returned is null.
	*/
	public void t_genRandomFile(String fileName, String mode, int size) throws T_Fail {

		RandomAccessFile iFile = null;
		try {
			iFile = new RandomAccessFile(fileName, mode);
			for (int i = 0; i < size; i++){
				byte b = (byte) (i & 0xff);
				b = (byte) (((b >= ' ') && (b <= '~')) ? b : ' ');
				iFile.write(b);
			}
			iFile.close();
		} catch (FileNotFoundException fnfe) {
			throw T_Fail.testFailMsg("cannot create new file");
		} catch (IOException ioe) {
			throw T_Fail.testFailMsg("io error, test failed");
		}

	}

	/**
		Return a string of stringLen characters that starts with data
		and is padded with nulls.
	*/
	public static String getStringFromData(String data, int stringLen) {
		char[] ca = new char[stringLen];

		char[] sd = data.toCharArray();

		System.arraycopy(sd, 0, ca, 0, sd.length);

		return new String(ca);
	}

	/**
		Make this thread wait a bit, probably for post commit to finish
	 */
	public static void t_wait(int milliSecond)
	{
		Thread.currentThread().yield();
		try
		{
			Thread.currentThread().sleep(milliSecond);
		}
		catch (InterruptedException ie)
		{
		}
	}

	/**
		Add in encryption parameters to the startParam if "testDataEncryption"
		is set to a non-null string.
	 */
	public static Properties setEncryptionParam(Properties startParams)
	{
		// see if we are testing encryption
		String encryptionPassword =
					PropertyUtil.getSystemProperty("testDataEncryption");
		//look for alternate encryption provider
		String encryptionProvider =
					PropertyUtil.getSystemProperty("testEncryptionProvider");
		if (encryptionPassword != null)
		{
			if (startParams == null)
				startParams = new Properties();

			startParams.put(Attribute.DATA_ENCRYPTION, "true");
			startParams.put(Attribute.BOOT_PASSWORD, encryptionPassword);
			if (encryptionProvider != null) {
			    startParams.put(Attribute.CRYPTO_PROVIDER, encryptionProvider);
			}

			//			System.out.println("Setting encryption password to " + encryptionPassword);

		}

		return startParams;
	}

}


text:
//! Text mode terminal handler.

use core::fmt;
use core::mem;

use alloc::boxed::Box;

use crate::multiboot;
use crate::constants::translate_low_addr;

pub mod vga;
pub use vga::{VgaConfig, Vga};

pub mod graphical;
pub use graphical::Graphical;

/// Colors common to most terminals.
///
/// Numeric values correspond to the VGA text mode palette.
#[repr(u8)]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
pub enum Color {
    Black        = 0,
    Blue         = 1,
    Green        = 2,
    Cyan         = 3,
    Red          = 4,
    Magenta      = 5,
    Brown        = 6,
    LightGrey    = 7,
    DarkGrey     = 8,
    LightBlue    = 9,
    LightGreen   = 10,
    LightCyan    = 11,
    LightRed     = 12,
    LightMagenta = 13,
    LightBrown   = 14,
    White        = 15,
}

static LIGHT_COLORS: [Color; 8] = [
    Color::DarkGrey,
    Color::LightBlue,
    Color::LightGreen,
    Color::LightCyan,
    Color::LightRed,
    Color::LightMagenta,
    Color::LightBrown,
    Color::White,
];

static DARK_COLORS: [Color; 8] = [
    Color::Black,
    Color::Blue,
    Color::Green,
    Color::Cyan,
    Color::Red,
    Color::Magenta,
    Color::Brown,
    Color::LightGrey,
];

static COLORS_RGB: [u32; 16] = [
    0x000000, //black
    0x000080, //blue
    0x008000, //green
    0x008080, //cyan
    0x800000, //red
    0x800080, //magenta
    0x808000, //brown
    0xc0c0c0, //light grey
    0x404040, //dark grey,
    0x0000ff, //light blue
    0x00ff00, //light green
    0x00ffff, //light cyan
    0xff0000, //light red
    0xff00ff, //light magenta
    0xffff00, //light brown (yellow)
    0xffffff, //white
];

impl Color {
    pub fn lighten(self) -> Color {
        LIGHT_COLORS[self as usize % 8]
    }

    pub fn darken(self) -> Color {
        DARK_COLORS[self as usize % 8]
    }

    pub fn to_rgb(self) -> u32 {
        COLORS_RGB[self as usize]
    }
}

/// A terminal.
pub trait Terminal: fmt::Write {
    /// Reset the terminal to its initial state.
    fn reset(&mut self) -> fmt::Result;

    /// Clear the terminal buffer.
    fn clear(&mut self) -> fmt::Result;

    /// Get the current `(row, col)` position of the cursor.
    fn get_cursor(&self) -> (usize, usize);

    /// Set the cursor to a given `(row, col)` position.
    fn set_cursor(&mut self, row: usize, col: usize) -> fmt::Result;

    /// Get the current color set of the terminal.
    ///
    /// These colors are used for every method that writes to the terminal except
    /// `put_raw_byte()`, which specifies its own set of foreground and
    /// background colors.
    fn get_color(&self) -> (Color, Color);

    /// Set the current color set of the terminal.
    ///
    /// These colors must be used for any subsequent calls to any methods that
    /// write to the terminal, with the exception of `put_raw_byte()`, which
    /// specifies its own set of foreground and background colors.
    fn set_color(&mut self, fg: Color, bg: Color) -> fmt::Result;

    /// Put a byte at the given `(row, col)` position with the given foreground
    /// and background colors, without changing the cursor or the current color
    /// set of the terminal.
    ///
    /// The results of `get_cursor()` and `get_color()` must not be changed by
    /// this function.
    fn put_raw_byte(&mut self,
                    byte: u8,
                    fg:   Color,
                    bg:   Color,
                    row:  usize,
                    col:  usize) -> fmt::Result;

    /// Write a raw byte at the current cursor position with the current color
    /// set.
    ///
    /// May not `flush()`, if applicable.
    fn write_raw_byte(&mut self, byte: u8) -> fmt::Result;

    /// Write a byte slice at the current cursor position with the current color
    /// set.
    ///
    /// May not `flush()`, if applicable.
    fn write_raw_bytes(&mut self, bytes: &[u8]) -> fmt::Result {
        for byte in bytes {
            self.write_raw_byte(*byte)?;
        }

        Ok(())
    }

    /// Enable or disable double buffering.
    ///
    /// This method is a no-op if not supported.
    fn set_double_buffer(&mut self, enabled: bool) { }

    /// Flushes any internally deferred commands or buffers, if applicable.
    ///
    /// The `Write` implementation should automatically call this.
    ///
    /// For example, `Vga` uses this to update the cursor, since writing to IO
    /// ports can be slow.
    fn flush(&mut self) -> fmt::Result;
}

/// Wraps a Terminal to make it compatible with ANSI escape sequences.
pub struct Ansi<T> {
    term:  T,
    state: AnsiState,
    bold:  bool,
}

#[derive(Debug, Clone, Copy)]
enum AnsiState {
    Normal,
    StartSeq,
    Csi(u8, bool, [u8; 16])
}

impl AnsiState {
    fn csi_digit(&mut self, digit: u8) {
        match *self {
            AnsiState::Csi(ref mut size, ref mut new, ref mut buf) => {
                if *new {
                    if (*size as usize) >= buf.len() { return }

                    *size += 1;
                    *new   = false;
                }

                let index = (*size as usize) - 1;

                buf[index] = buf[index] * 10 + digit;
            },

            _ => panic!("csi_digit() called on {:?}", self)
        }
    }

    fn csi_push(&mut self) {
        match *self {
            AnsiState::Csi(ref mut size, ref mut new, ref mut buf) => {
                if *new {
                    if (*size as usize) < buf.len() {
                        *size += 1;
                    }
                } else {
                    *new = true;
                }
            },

            _ => panic!("csi_push() called on {:?}", self)
        }
    }

    fn csi_finish(&self) -> &[u8] {
        match *self {
            AnsiState::Csi(size, _, ref buf) => &buf[0..(size as usize)],

            _ => panic!("csi_finish() called on {:?}", self)
        }
    }
}

static ANSI_ATTR_TABLE: [Color; 8] = [
    Color::Black,
    Color::Red,
    Color::Green,
    Color::Brown,
    Color::Blue,
    Color::Magenta,
    Color::Cyan,
    Color::LightGrey,
];

impl<T: Terminal> Ansi<T> {
    /// Wrap an existing Terminal to make it compatible with ANSI escape
    /// sequences.
    pub fn new(term: T) -> Ansi<T> {
        Ansi { term: term, state: AnsiState::Normal, bold: false }
    }

    fn csi_sgr(&mut self) -> fmt::Result {
        let state = mem::replace(&mut self.state, AnsiState::Normal);

        let (mut fg, mut bg) = self.term.get_color();

        for attr in state.csi_finish() {
            match *attr {
                0 => {
                    self.bold = false;

                    fg = Color::LightGrey;
                    bg = Color::Black;
                },

                1 => {
                    self.bold = true;
                },

                22 => {
                    self.bold = false;
                },

                30..=37 => { fg = ANSI_ATTR_TABLE[(attr - 30) as usize]; },
                40..=47 => { bg = ANSI_ATTR_TABLE[(attr - 40) as usize]; },

                _ => ()
            }
        }

        if self.bold {
            fg = fg.lighten();
        } else {
            fg = fg.darken();
        }

        self.term.set_color(fg, bg)
    }
}

impl<T: Terminal> Terminal for Ansi<T> {
    fn reset(&mut self) -> fmt::Result {
        self.term.reset().and_then(|_| {
            self.state = AnsiState::Normal;
            self.bold  = false;
            Ok(())
        })
    }

    fn clear(&mut self) -> fmt::Result {
        self.term.clear()
    }

    fn get_cursor(&self) -> (usize, usize) {
        self.term.get_cursor()
    }

    fn set_cursor(&mut self, row: usize, col: usize) -> fmt::Result {
        self.term.set_cursor(row, col)
    }

    fn get_color(&self) -> (Color, Color) {
        self.term.get_color()
    }

    fn set_color(&mut self, fg: Color, bg: Color) -> fmt::Result {
        self.term.set_color(fg, bg)
    }

    fn put_raw_byte(&mut self,
                    byte: u8,
                    fg:   Color,
                    bg:   Color,
                    row:  usize,
                    col:  usize) -> fmt::Result {

        self.term.put_raw_byte(byte, fg, bg, row, col)
    }

    fn write_raw_byte(&mut self, byte: u8) -> fmt::Result {
        match self.state {
            AnsiState::Normal if byte == 0x1b /* escape */ => {
                self.state = AnsiState::StartSeq;
                Ok(())
            },

            AnsiState::Normal =>
                self.term.write_raw_byte(byte),

            AnsiState::StartSeq => match byte {
                b'[' => {
                    self.state = AnsiState::Csi(1, false, [0; 16]);
                    Ok(())
                },

                _ => {
                    self.state = AnsiState::Normal;
                    self.term.write_raw_byte(byte)
                }
            },

            AnsiState::Csi(_,_,_) => match byte {
                b'0'..=b'9' => {
                    self.state.csi_digit(byte - b'0');
                    Ok(())
                },

                b';' => {
                    self.state.csi_push();
                    Ok(())
                },

                b'm' => {
                    self.csi_sgr()
                },

                _ => {
                    self.state = AnsiState::Normal;
                    Ok(())
                }
            }
        }
    }

    fn set_double_buffer(&mut self, enabled: bool) {
        self.term.set_double_buffer(enabled)
    }

    fn flush(&mut self) -> fmt::Result {
        self.term.flush()
    }
}

impl<T: Terminal> fmt::Write for Ansi<T> {
    fn write_char(&mut self, ch: char) -> fmt::Result {
        let mut buf = [0; 4];
        self.write_raw_bytes(ch.encode_utf8(&mut buf).as_bytes())?;
        self.flush()?;
        Ok(())
    }

    fn write_str(&mut self, s: &str) -> fmt::Result {
        self.write_raw_bytes(s.as_bytes())?;
        self.flush()?;
        Ok(())
    }
}

/// Ignores all commands and does nothing. Useful initial state.
pub struct Null;

impl Terminal for Null {
    fn reset(&mut self) -> fmt::Result {
        Ok(())
    }

    fn clear(&mut self) -> fmt::Result {
        Ok(())
    }

    fn get_cursor(&self) -> (usize, usize) {
        (0, 0)
    }

    fn set_cursor(&mut self, _row: usize, _col: usize) -> fmt::Result {
        Ok(())
    }

    fn get_color(&self) -> (Color, Color) {
        (Color::White, Color::Black)
    }

    fn set_color(&mut self, _fg: Color, _bg: Color) -> fmt::Result {
        Ok(())
    }

    fn put_raw_byte(&mut self,
                    _byte: u8,
                    _fg:   Color,
                    _bg:   Color,
                    _row:  usize,
                    _col:  usize) -> fmt::Result {

        Ok(())
    }

    fn write_raw_byte(&mut self, _byte: u8) -> fmt::Result {
        Ok(())
    }

    fn flush(&mut self) -> fmt::Result {
        Ok(())
    }
}

impl fmt::Write for Null {
    fn write_char(&mut self, _ch: char) -> fmt::Result {
        Ok(())
    }

    fn write_str(&mut self, _s: &str) -> fmt::Result {
        Ok(())
    }
}

/// Build chars from streaming bytes
#[derive(Debug, Clone, Default)]
struct CharStream {
    char_buf: [u8; 4],
    char_index: u8,
}

impl CharStream {
    fn consume(&mut self) -> Option<char> {
        if self.char_index == 0 {
            return None;
        }

        let utf8 = &self.char_buf[0..self.char_index as usize];

        match core::str::from_utf8(utf8) {
            Ok(s) => {
                self.char_index = 0;
                s.chars().next()
            },
            Err(e) => match e.error_len() {
                None => {
                    // ok, wait for more bytes
                    None
                },
                Some(invalid_end) => {
                    // move invalid end to the beginning
                    self.char_buf.copy_within(invalid_end.., 0);
                    self.char_index -= invalid_end as u8;
                    // produce fffd (replacement char)
                    Some('\u{fffd}')
                },
            }
        }
    }

    /// Call consume() in a loop after calling push
    fn push(&mut self, byte: u8) {
        self.char_buf[self.char_index as usize] = byte;
        self.char_index += 1;
    }

    #[allow(dead_code)]
    fn reset(&mut self) {
        *self = CharStream::default();
    }
}

static mut NULL: Null = Null;
static mut CONSOLE: Option<*mut dyn Terminal> = None;

/// Initialize the global console.
pub unsafe fn initialize(info: &multiboot::Info) {
    assert!(CONSOLE.is_none());

    match info.framebuffer_type {
        1 /* Linear framebuffer, rgb */ => {
            use crate::framebuffer::*;

            assert!((info.framebuffer_height as usize *
                info.framebuffer_pitch as usize) < 0x8000_0000);

            assert!(info.framebuffer_addr < usize::MAX as u64);

            let fb = LinearFramebuffer::map(LinearPixelConfig {
                buffer: 0xffff_ffff_0000_0000 as *mut u8,
                width: info.framebuffer_width as usize,
                height: info.framebuffer_height as usize,
                pitch: info.framebuffer_pitch as usize,
                bits_per_pixel: info.framebuffer_bpp,
                color_format: ColorFormat::Rgb {
                    red: MaskShift {
                        mask_bits: info.color_info.rgb.framebuffer_red_mask_size,
                        shift: info.color_info.rgb.framebuffer_red_field_position,
                    },
                    green: MaskShift {
                        mask_bits: info.color_info.rgb.framebuffer_green_mask_size,
                        shift: info.color_info.rgb.framebuffer_green_field_position,
                    },
                    blue: MaskShift {
                        mask_bits: info.color_info.rgb.framebuffer_blue_mask_size,
                        shift: info.color_info.rgb.framebuffer_blue_field_position,
                    },
                },
            }, info.framebuffer_addr as usize);

            let font = graphical::u_vga16();

            let ansi_graphical = Ansi::new(Graphical::new(fb, font));

            CONSOLE = Some(Box::leak(Box::new(ansi_graphical)));
        },
        2 /* VGA */ => {
            assert!(info.framebuffer_addr < u32::MAX as u64);

            let ansi_vga = Ansi::new(Vga::new(VgaConfig {
                width: info.framebuffer_width as usize,
                height: info.framebuffer_height as usize,
                buffer: translate_low_addr::<u16>(info.framebuffer_addr as u32)
                    .unwrap() as *mut _,
                port: 0x3d4,
            }));

            CONSOLE = Some(Box::leak(Box::new(ansi_vga)));
        },
        _ => {
            warn!("Unknown framebuffer type {}. \
                Terminal will not be initialized", info.framebuffer_type);
        }
    }
}

/// Get the current global console.
pub fn console() -> &'static mut dyn Terminal {
    unsafe {
        if CONSOLE.is_none() {
            &mut NULL
        } else {
            CONSOLE.unwrap().as_mut().unwrap()
        }
    }
}

/// C (legacy) interface. See `kit/kernel/include/terminal.h`.
pub mod ffi {
    use super::*;

    use core::mem;
    use core::slice;

    use crate::c_ffi::{c_char, size_t};

    #[no_mangle]
    pub extern fn terminal_initialize() {
        console().reset().unwrap();
    }

    #[no_mangle]
    pub extern fn terminal_clear() {
        console().clear().unwrap();
    }

    #[no_mangle]
    pub extern fn terminal_updatecursor() {
        console().flush().unwrap();
    }

    #[no_mangle]
    pub unsafe extern fn terminal_getcursor(row: *mut size_t, column: *mut size_t) {
        let (row_us, col_us) = console().get_cursor();

        *row    = row_us as size_t;
        *column = col_us as size_t;
    }

    #[no_mangle]
    pub extern fn terminal_setcursor(row: size_t, column: size_t) {
        console().set_cursor(row as usize, column as usize).unwrap();
    }

    #[repr(C)]
    #[derive(Clone, Copy)]
    pub enum VgaColor {
        Black        = 0,
        Blue         = 1,
        Green        = 2,
        Cyan         = 3,
        Red          = 4,
        Magenta      = 5,
        Brown        = 6,
        LightGrey    = 7,
        DarkGrey     = 8,
        LightBlue    = 9,
        LightGreen   = 10,
        LightCyan    = 11,
        LightRed     = 12,
        LightMagenta = 13,
        LightBrown   = 14,
        White        = 15,
    }

    impl VgaColor {
        pub fn from_color(color: Color) -> VgaColor {
            unsafe { mem::transmute(color as i32) }
        }

        pub fn to_color(self) -> Color {
            unsafe { mem::transmute(self as u8) }
        }
    }

    #[no_mangle]
    pub unsafe extern fn terminal_getcolor(fg: *mut VgaColor,
                                           bg: *mut VgaColor) {
        let (fg_c, bg_c) = console().get_color();

        *fg = VgaColor::from_color(fg_c);
        *bg = VgaColor::from_color(bg_c);
    }

    #[no_mangle]
    pub extern fn terminal_setcolor(fg: VgaColor, bg: VgaColor) {
        console().set_color(fg.to_color(), bg.to_color()).unwrap();
    }

    #[no_mangle]
    pub unsafe extern fn terminal_putentryat(c: c_char,
                                      color: u8,
                                      x: size_t,
                                      y: size_t) {

        let fg_v: VgaColor = mem::transmute((color & 0x0f) as i32);
        let bg_v: VgaColor = mem::transmute((color >> 4)   as i32);

        console()
            .put_raw_byte(c as u8,
                          fg_v.to_color(),
                          bg_v.to_color(),
                          y as usize,
                          x as usize)
            .unwrap();
    }

    #[no_mangle]
    pub extern fn terminal_newline() {
        console().write_raw_byte('\n' as u8).unwrap();
        console().flush().unwrap();
    }

    #[no_mangle]
    pub extern fn terminal_writechar_internal(c: c_char) {
        console().write_raw_byte(c as u8).unwrap();
    }

    #[no_mangle]
    pub extern fn terminal_writechar(c: c_char) {
        console().write_raw_byte(c as u8).unwrap();
        console().flush().unwrap();
    }

    #[no_mangle]
    pub unsafe extern fn terminal_writebuf(length: u64, buffer: *const u8) {
        let bytes = slice::from_raw_parts(buffer, length as usize);

        console().write_raw_bytes(bytes).unwrap();
        console().flush().unwrap();
    }

    #[no_mangle]
    pub unsafe extern fn terminal_writestring(data: *const u8) {
        let mut data_len = 0usize;
        let mut data_end = data;

        while *data_end != 0 {
            data_len += 1;
            data_end = data_end.offset(1);
        }

        let bytes = slice::from_raw_parts(data, data_len);

        console().write_raw_bytes(bytes).unwrap();
        console().flush().unwrap();
    }
}

redpajama_set_name: RedPajamaGithub


text:
<?php

use Phinx\Migration\AbstractMigration;

class AccountSecurityEvent extends AbstractMigration
{
    public function change()
    {
        $this->table('UserLoginHistories')
             ->rename('AccountSecurityEvents')
             ->renameColumn('type', 'auth_strategy')
             ->addColumn('type', 'string', ['after' => 'user_id'])
             ->addColumn('description', 'string', ['after' => 'user_agent'])
             ->update();

        $this->table('AccountSecurityEvents')
             ->changeColumn('auth_strategy', 'string', ['null' => true, 'default' => null, 'after' => 'description'])
             ->update();

        $this->execute('UPDATE AccountSecurityEvents SET type="user.login"');
    }
}


text:
import utils from '../utils'
import config from '../config'

const PIECE_PROTOTYPE = {
  contains(x, y) {
    if (!this.mask[y]) {
      return false;
    }
    return this.mask[y][utils.mod(x, this.MAX_X)];
  },
  getPoints() {
    return this.points;
  },
  isEmpty() {
    return this.points.length === 0;
  },
  rowIsEmpty(row) {
    if (!this.mask[row]) {
      return true;
    }
    return Object.keys(this.mask[row]).length === 0;
  },
  rowHasEnough(row, length) {
    if (!this.mask[row]) {
      return false;
    }
    return Object.keys(this.mask[row]).length >= length;
  },
  getColor(x, y) {
    return this.mask[y][x];
  }
};

const dropPiece = (piece) => {
  const points = [];

  piece.points.forEach((element, index) => {
    points.push({x: element.x, y: element.y-1, color: element.color});
  });

  let root = null;
  if (piece.root) {
    root = {x: piece.root.x, y: piece.root.y-1};
  }

  return createPiece(points, piece.MAX_X, piece.color, root);
}

const shiftPiece = (piece, distance) => {
  const points = [];

  piece.points.forEach((element, index) => {
    points.push({x: element.x+distance, y: element.y, color: element.color});
  });

  let root = null;
  if (piece.root) {
    root = {x: piece.root.x+distance, y: piece.root.y};
  }

  return createPiece(points, piece.MAX_X, piece.color, root);
}

// assume we always go clockwise
const rotatePiece = (piece, clockwise) => {
  if (!piece.root) {
    return piece;
  }

  const points = [];
  piece.getPoints().forEach((point) => {
    const dx = point.x - piece.root.x;
    const dy = point.y - piece.root.y;
    if (!clockwise) {
      points.push({x: piece.root.x + dy, y: piece.root.y - dx, color: point.color});
    } else {
      points.push({x: piece.root.x - dy, y: piece.root.y + dx, color: point.color})
    }
  });

  return createPiece(points, piece.MAX_X, piece.color, piece.root);
}

const createPiece = (points, max, color, root) => {
  const p = Object.create(PIECE_PROTOTYPE);

  p.points = [];

  // MASK IS Y:X CAUSE THAT WAY IS BETTER
  p.mask = {};
  p.root = root;

  points.forEach((point) => {
    p.points.push(point);

    // create new column if needed
    if(!p.mask[point.y]) {
      p.mask[point.y] = {};
    }
    // mask must be correct for x limits
    p.mask[point.y][utils.mod(point.x, max)] = point.color;
  });

  p.color = color || null;
  p.MAX_X = max;

  return p;
}

const mergePieces = (first, second) => {
  const points = [];

  first.points.forEach((element) => {
    points.push({x: element.x, y: element.y, color: element.color});
  });

  second.points.forEach((element) => {
    points.push({x: element.x, y: element.y, color: element.color});
  });

  return createPiece(points, first.MAX_X, first.color, first.root);
}

export { createPiece, dropPiece, mergePieces, shiftPiece, rotatePiece }


text:
package apple.uikit;

import apple.NSObject;
import apple.coregraphics.opaque.CGContextRef;
import apple.coregraphics.struct.CGRect;
import apple.coregraphics.struct.CGSize;
import apple.foundation.NSArray;
import apple.foundation.NSData;
import apple.foundation.NSMethodSignature;
import apple.foundation.NSSet;
import org.moe.natj.c.ann.FunctionPtr;
import org.moe.natj.general.NatJ;
import org.moe.natj.general.Pointer;
import org.moe.natj.general.ann.ByValue;
import org.moe.natj.general.ann.Generated;
import org.moe.natj.general.ann.Library;
import org.moe.natj.general.ann.Mapped;
import org.moe.natj.general.ann.NFloat;
import org.moe.natj.general.ann.NInt;
import org.moe.natj.general.ann.NUInt;
import org.moe.natj.general.ann.Owned;
import org.moe.natj.general.ann.Runtime;
import org.moe.natj.general.ptr.VoidPtr;
import org.moe.natj.objc.Class;
import org.moe.natj.objc.ObjCRuntime;
import org.moe.natj.objc.SEL;
import org.moe.natj.objc.ann.ObjCBlock;
import org.moe.natj.objc.ann.ObjCClassBinding;
import org.moe.natj.objc.ann.Selector;
import org.moe.natj.objc.map.ObjCObjectMapper;

@Generated
@Library("UIKit")
@Runtime(ObjCRuntime.class)
@ObjCClassBinding
public class UIGraphicsImageRenderer extends UIGraphicsRenderer {
    static {
        NatJ.register();
    }

    @Generated
    protected UIGraphicsImageRenderer(Pointer peer) {
        super(peer);
    }

    @Generated
    @Selector("accessInstanceVariablesDirectly")
    public static native boolean accessInstanceVariablesDirectly();

    @Generated
    @Owned
    @Selector("alloc")
    public static native UIGraphicsImageRenderer alloc();

    @Owned
    @Generated
    @Selector("allocWithZone:")
    public static native UIGraphicsImageRenderer allocWithZone(VoidPtr zone);

    @Generated
    @Selector("automaticallyNotifiesObserversForKey:")
    public static native boolean automaticallyNotifiesObserversForKey(String key);

    @Generated
    @Selector("cancelPreviousPerformRequestsWithTarget:")
    public static native void cancelPreviousPerformRequestsWithTarget(@Mapped(ObjCObjectMapper.class) Object aTarget);

    @Generated
    @Selector("cancelPreviousPerformRequestsWithTarget:selector:object:")
    public static native void cancelPreviousPerformRequestsWithTargetSelectorObject(
            @Mapped(ObjCObjectMapper.class) Object aTarget, SEL aSelector,
            @Mapped(ObjCObjectMapper.class) Object anArgument);

    @Generated
    @Selector("classFallbacksForKeyedArchiver")
    public static native NSArray<String> classFallbacksForKeyedArchiver();

    @Generated
    @Selector("classForKeyedUnarchiver")
    public static native Class classForKeyedUnarchiver();

    @Generated
    @Selector("debugDescription")
    public static native String debugDescription_static();

    @Generated
    @Selector("description")
    public static native String description_static();

    @Generated
    @Selector("hash")
    @NUInt
    public static native long hash_static();

    @Generated
    @Selector("instanceMethodForSelector:")
    @FunctionPtr(name = "call_instanceMethodForSelector_ret")
    public static native NSObject.Function_instanceMethodForSelector_ret instanceMethodForSelector(SEL aSelector);

    @Generated
    @Selector("instanceMethodSignatureForSelector:")
    public static native NSMethodSignature instanceMethodSignatureForSelector(SEL aSelector);

    @Generated
    @Selector("instancesRespondToSelector:")
    public static native boolean instancesRespondToSelector(SEL aSelector);

    @Generated
    @Selector("isSubclassOfClass:")
    public static native boolean isSubclassOfClass(Class aClass);

    @Generated
    @Selector("keyPathsForValuesAffectingValueForKey:")
    public static native NSSet<String> keyPathsForValuesAffectingValueForKey(String key);

    @Generated
    @Owned
    @Selector("new")
    public static native UIGraphicsImageRenderer new_objc();

    @Generated
    @Selector("resolveClassMethod:")
    public static native boolean resolveClassMethod(SEL sel);

    @Generated
    @Selector("resolveInstanceMethod:")
    public static native boolean resolveInstanceMethod(SEL sel);

    @Generated
    @Selector("setVersion:")
    public static native void setVersion_static(@NInt long aVersion);

    @Generated
    @Selector("superclass")
    public static native Class superclass_static();

    @Generated
    @Selector("version")
    @NInt
    public static native long version_static();

    @Generated
    @Selector("JPEGDataWithCompressionQuality:actions:")
    public native NSData JPEGDataWithCompressionQualityActions(@NFloat double compressionQuality,
            @ObjCBlock(name = "call_JPEGDataWithCompressionQualityActions") Block_JPEGDataWithCompressionQualityActions actions);

    /**
     * These return compressed image data with the contents of the image drawn in the renderer block.
     */
    @Generated
    @Selector("PNGDataWithActions:")
    public native NSData PNGDataWithActions(
            @ObjCBlock(name = "call_PNGDataWithActions") Block_PNGDataWithActions actions);

    /**
     * Returns a UIImage rendered with the contents of the CGContext after the imageRenderBlock executes.
     * If the options provided to the renderer contain a rect with a zero width or height size, this will return an
     * empty UIImage.
     */
    @Generated
    @Selector("imageWithActions:")
    public native UIImage imageWithActions(@ObjCBlock(name = "call_imageWithActions") Block_imageWithActions actions);

    @Generated
    @Selector("init")
    public native UIGraphicsImageRenderer init();

    @Generated
    @Selector("initWithBounds:")
    public native UIGraphicsImageRenderer initWithBounds(@ByValue CGRect bounds);

    @Generated
    @Selector("initWithBounds:format:")
    public native UIGraphicsImageRenderer initWithBoundsFormat(@ByValue CGRect bounds,
            UIGraphicsImageRendererFormat format);

    @Generated
    @Selector("initWithSize:")
    public native UIGraphicsImageRenderer initWithSize(@ByValue CGSize size);

    @Generated
    @Selector("initWithSize:format:")
    public native UIGraphicsImageRenderer initWithSizeFormat(@ByValue CGSize size,
            UIGraphicsImageRendererFormat format);

    @Runtime(ObjCRuntime.class)
    @Generated
    public interface Block_JPEGDataWithCompressionQualityActions {
        @Generated
        void call_JPEGDataWithCompressionQualityActions(UIGraphicsImageRendererContext rendererContext);
    }

    @Runtime(ObjCRuntime.class)
    @Generated
    public interface Block_PNGDataWithActions {
        @Generated
        void call_PNGDataWithActions(UIGraphicsImageRendererContext rendererContext);
    }

    @Runtime(ObjCRuntime.class)
    @Generated
    public interface Block_imageWithActions {
        @Generated
        void call_imageWithActions(UIGraphicsImageRendererContext rendererContext);
    }

    @Generated
    @Selector("contextWithFormat:")
    public static native CGContextRef contextWithFormat(UIGraphicsRendererFormat format);

    @Generated
    @Selector("prepareCGContext:withRendererContext:")
    public static native void prepareCGContextWithRendererContext(CGContextRef context,
            UIGraphicsRendererContext rendererContext);

    @Generated
    @Selector("rendererContextClass")
    public static native Class rendererContextClass();
}


text:
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

/**
* @name: S12.6.2_A15;
* @section: 12.6.2;
* @assertion: Block within a "while" Expression is not allowed;
* @description: Expression is "{0}";
* @negative;
*/

//////////////////////////////////////////////////////////////////////////////
//CHECK#
while({1}){
   break ;
};
//
//////////////////////////////////////////////////////////////////////////////


text:
var monthlySalesModule = angular.module('monthlySales', ['angularGrid']);

monthlySalesModule.controller('monthlySalesController', function($scope, $http) {

    var monthValueGetter = '(ctx.month < colDef.month) ? data[colDef.field + "_bud"] : data[colDef.field + "_act"]';
    var monthCellClassRules = {
        'cell-act': 'ctx.month < colDef.month',
        'cell-bud': 'ctx.month >= colDef.month',
        'cell-negative': 'x < 0'
    };
    var yearToDateValueGetter = 'var total = 0; ctx.months.forEach( function(monthName, monthIndex) { if (monthIndex<=ctx.month) { total += data[monthName + "_act"]; } }); return total; ';
    var accountingCellRenderer = function(params) {
        if (params.value >= 0) {
            return params.value.toLocaleString();
        } else {
            return '(' + Math.abs(params.value).toLocaleString() + ')';
        }
    };

    var columnDefs = [
        {headerName : 'Jan', headerGroup: 'Monthly Data', field: 'jan', month: 0, cellRenderer: accountingCellRenderer,
            cellClass: 'cell-figure', valueGetter: monthValueGetter, cellClassRules: monthCellClassRules},

        {headerName : 'Feb', headerGroup: 'Monthly Data', field: 'feb', month: 1, cellRenderer: accountingCellRenderer,
            cellClass: 'cell-figure', valueGetter: monthValueGetter, cellClassRules: monthCellClassRules},

        {headerName : 'Mar', headerGroup: 'Monthly Data', field: 'mar', month: 2, cellRenderer: accountingCellRenderer,
            cellClass: 'cell-figure', valueGetter: monthValueGetter, cellClassRules: monthCellClassRules},

        {headerName : 'Apr', headerGroup: 'Monthly Data', field: 'apr', month: 3, cellRenderer: accountingCellRenderer,
            cellClass: 'cell-figure', valueGetter: monthValueGetter, cellClassRules: monthCellClassRules},

        {headerName : 'May', headerGroup: 'Monthly Data', field: 'may', month: 4, cellRenderer: accountingCellRenderer,
            cellClass: 'cell-figure', valueGetter: monthValueGetter, cellClassRules: monthCellClassRules},

        {headerName : 'Jun', headerGroup: 'Monthly Data', field: 'jun', month: 5, cellRenderer: accountingCellRenderer,
            cellClass: 'cell-figure', valueGetter: monthValueGetter, cellClassRules: monthCellClassRules},

        {headerName : 'YTD', headerGroup: 'Totals', cellClass: 'cell-figure', cellRenderer: accountingCellRenderer,
            valueGetter: yearToDateValueGetter, cellStyle: {'font-weight': 'bold'}}

    ];

    $scope.gridOptions = {
        groupColumnDef: {headerName : "Location", field: "city", width: 200,
            cellRenderer: {
                renderer: 'group',
                checkbox: true
            }
        },
        columnDefs: columnDefs,
        colWidth: 100,
        rowSelection: 'multiple',
        enableColResize: true,
        enableSorting: true,
        enableFilter: true,
        groupHeaders: true,
        groupKeys: ['country'],
        rowHeight: 22,
        modelUpdated: modelUpdated,
        groupSelectsChildren: true,
        context: {
            month: 0,
            months: ['jan','feb','mar','apr','may','jun','jul','aug','sep','oct','nov','dec']
        },
        ready: function(event) {
            event.api.sizeColumnsToFit();
        },
        icons: {
            menu: '<i class="fa fa-bars"/>',
            filter: '<i class="fa fa-filter"/>',
            sortAscending: '<i class="fa fa-long-arrow-down"/>',
            sortDescending: '<i class="fa fa-long-arrow-up"/>',
            groupExpanded: '<i class="fa fa-minus-square-o"/>',
            groupContracted: '<i class="fa fa-plus-square-o"/>',
            headerGroupOpened: '<i class="fa fa-minus-square-o"/>',
            headerGroupClosed: '<i class="fa fa-plus-square-o"/>'
        },
        groupAggFunction: groupAggFunction
    };

    var monthNames = ['Full Year', 'Year to Jan', 'Year to Feb', 'Year to Mar', 'Year to Apr', 'Year to May',
        'Year to Jun', 'Year to Jul', 'Year to Aug', 'Year to Sep', 'Year to Oct', 'Year to Nov', 'Full Year',];

    $scope.monthName = monthNames[1];

    $scope.onChangeMonth = function(i) {
        var newMonth = $scope.gridOptions.context.month += i;

        if (newMonth < -1) {
            newMonth = -1;
        }
        if (newMonth > 5) {
            newMonth = 5;
        }

        $scope.gridOptions.context.month = newMonth;
        $scope.monthName = monthNames[newMonth + 1];
        $scope.gridOptions.api.refreshView();
    };

    function groupAggFunction(rows) {

        var aggFields = [
                'jan_act','jan_bud','feb_act','feb_bud','mar_act','mar_bud',
                'apr_act','apr_bud','may_act','may_bud','jun_act','jun_bud',
                'jul_act','jul_bud','aug_act','aug_bud','sep_act','sep_bud',
                'oct_act','oct_bud','nov_act','nov_bud','dec_act','dec_bud'];

        var data = {};

        for (var j = 0; j<aggFields.length; j++) {
            data[aggFields[j]] = 0;
        }

        for (var i = 0; i<rows.length; i++) {
            for (var k = 0; k<aggFields.length; k++) {
                var aggField = aggFields[k];
                var row = rows[i];
                data[aggField] += row.data[aggField];
            }
        }

        return data;
    }

    $http.get("./monthlySales.json")
        .then(function(res){
            $scope.gridOptions.rowData = res.data;
            $scope.gridOptions.api.onNewRows();
            $scope.gridOptions.api.sizeColumnsToFit();
        });

    function modelUpdated() {
        if ($scope.gridOptions.rowData) {
            var model = $scope.gridOptions.api.getModel();
            var totalRows = $scope.gridOptions.rowData.length;
            var processedRows = model.getVirtualRowCount();
            $scope.rowCount = processedRows.toLocaleString() + ' / ' + totalRows.toLocaleString();
        }
    }
});


text:
namespace PIL
{
	typedef struct PILExport FileInfo_t {
		uint32		attrib;
		int64		time_write;
		uint32		size;
		std::string name;
	}FileInfo;

	typedef std::vector<FileInfo> FileInfo_Vec;
	typedef std::vector<std::string> FilePath_Vec;

	class PILExport FileSystem
	{
	public:
		FileSystem() {};
		~FileSystem() {};

		// File function

		// Directory function
		inline bool IsRelativePath(const std::string path)
		{
			if (path.empty())
				return true;
#if defined(PLATFORM_WIN32)
			if (isalpha(uint8(path[0])) && path[1] == ':')
				return false;
			else return true;
#else
			return path[0] != '/' && path[0] != '\\';
#endif
		}

		inline bool IsFileOrDirExist(const std::string path)
		{
			if (path.empty())
				return false;
#if defined(PLATFORM_WIN32)
			if (_access(path.c_str(), 0) == 0)
				return true;
			else return false;
#else
			if (access(path.c_str(), F_OK) == 0)
				return true;
			else return false;
#endif
		}

		inline std::string RelativeToAbsPath(const std::string relpath)
		{
			if (IsRelativePath(relpath))
			{
#if defined(PLATFORM_WIN32)
				char buf[260];
				if(_fullpath(buf, relpath.c_str(), 260) != NULL)
					return std::string(buf);
				else return "";
#else
				char buf[260];
				if(realpath(relpath.c_str(), buf) != NULL)
					return std::string(buf);
				else return "";
#endif
			}
			else return relpath;
		}

		HRESULT CreateDir(const std::string path);

		HRESULT RemoveDir(const std::string path);

		HRESULT RenameDir(const std::string oldname, const std::string newname);

		HRESULT GetFileList(const std::string path, FileInfo_Vec *filelist, bool recursive = false, const std::string filter = "*.*");
	};
}

#endif


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--
   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.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                      https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
    <artifactId>hadoop-yarn-server</artifactId>
    <groupId>org.apache.hadoop</groupId>
    <version>3.4.0-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  <artifactId>hadoop-yarn-server-applicationhistoryservice</artifactId>
  <version>3.4.0-SNAPSHOT</version>
  <name>Apache Hadoop YARN ApplicationHistoryService</name>

  <properties>
    <!-- Needed for generating FindBugs warnings using parent pom -->
    <yarn.basedir>${project.parent.parent.basedir}</yarn.basedir>
  </properties>

  <dependencies>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
    </dependency>
    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-common</artifactId>
      <scope>provided</scope>
    </dependency>

    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-annotations</artifactId>
    </dependency>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-core</artifactId>
      <scope>test</scope>
    </dependency>
    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-common</artifactId>
      <type>test-jar</type>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.google.inject.extensions</groupId>
      <artifactId>guice-servlet</artifactId>
    </dependency>
    <dependency>
      <groupId>com.google.protobuf</groupId>
      <artifactId>protobuf-java</artifactId>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.assertj</groupId>
      <artifactId>assertj-core</artifactId>
      <scope>test</scope>
    </dependency>
    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>com.google.inject</groupId>
      <artifactId>guice</artifactId>
    </dependency>
    <dependency>
      <groupId>com.sun.jersey.jersey-test-framework</groupId>
      <artifactId>jersey-test-framework-core</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.sun.jersey</groupId>
      <artifactId>jersey-json</artifactId>
    </dependency>
    <dependency>
      <groupId>com.sun.jersey.contribs</groupId>
      <artifactId>jersey-guice</artifactId>
    </dependency>
    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-yarn-common</artifactId>
      <type>test-jar</type>
      <scope>test</scope>
    </dependency>
    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-yarn-common</artifactId>
    </dependency>
    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-yarn-api</artifactId>
    </dependency>
    <dependency>
      <groupId>javax.xml.bind</groupId>
      <artifactId>jaxb-api</artifactId>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jettison</groupId>
      <artifactId>jettison</artifactId>
    </dependency>
    <dependency>
      <groupId>com.sun.jersey</groupId>
      <artifactId>jersey-core</artifactId>
    </dependency>
    <dependency>
      <groupId>com.sun.jersey</groupId>
      <artifactId>jersey-client</artifactId>
    </dependency>
    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
    </dependency>

    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-yarn-server-common</artifactId>
    </dependency>

    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>com.sun.jersey.jersey-test-framework</groupId>
      <artifactId>jersey-test-framework-grizzly2</artifactId>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>commons-collections</groupId>
      <artifactId>commons-collections</artifactId>
    </dependency>

    <dependency>
      <groupId>${leveldbjni.group}</groupId>
      <artifactId>leveldbjni-all</artifactId>
    </dependency>

    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-minikdc</artifactId>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-auth</artifactId>
      <scope>test</scope>
      <type>test-jar</type>
    </dependency>

    <!-- 'mvn dependency:analyze' fails to detect use of this dependency -->
    <dependency>
      <groupId>org.bouncycastle</groupId>
      <artifactId>bcprov-jdk15on</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>de.ruedigermoeller</groupId>
      <artifactId>fst</artifactId>
      <version>2.50</version>
      <exclusions>
        <exclusion>
          <groupId>org.javassist</groupId>
          <artifactId>javassist</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.xolstice.maven.plugins</groupId>
        <artifactId>protobuf-maven-plugin</artifactId>
        <executions>
          <execution>
            <id>src-compile-protoc</id>
            <configuration>
              <skip>false</skip>
              <additionalProtoPathElements>
                <additionalProtoPathElement>
                  ${basedir}/../../../../hadoop-common-project/hadoop-common/src/main/proto
                </additionalProtoPathElement>
                <additionalProtoPathElement>
                  ${basedir}/../../hadoop-yarn-api/src/main/proto
                </additionalProtoPathElement>
                <additionalProtoPathElement>
                  ${basedir}/../../hadoop-yarn-common/src/main/proto
                </additionalProtoPathElement>
                <additionalProtoPathElement>
                  ${basedir}/../hadoop-yarn-server-common/src/main/proto
                </additionalProtoPathElement>
              </additionalProtoPathElements>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>com.google.code.maven-replacer-plugin</groupId>
        <artifactId>replacer</artifactId>
        <executions>
          <execution>
            <id>replace-generated-sources</id>
            <configuration>
              <skip>false</skip>
            </configuration>
          </execution>
          <execution>
            <id>replace-sources</id>
            <configuration>
              <skip>false</skip>
            </configuration>
          </execution>
          <execution>
            <id>replace-test-sources</id>
            <configuration>
              <skip>false</skip>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <artifactId>maven-jar-plugin</artifactId>
        <executions>
          <execution>
            <goals>
              <goal>test-jar</goal>
            </goals>
            <phase>test-compile</phase>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>


text:
//
//  NSFileManager_SKNToolExtensions.h
//  SkimNotes
//
//  Created by Christiaan Hofman on 7/17/08.

#import <Foundation/Foundation.h>

@interface NSFileManager (SKNToolExtensions)

- (NSData *)SkimNotesAtPath:(NSString *)path error:(NSError **)outError;
- (NSString *)SkimTextNotesAtPath:(NSString *)path error:(NSError **)outError;
- (NSData *)SkimRTFNotesAtPath:(NSString *)path error:(NSError **)outError;

- (BOOL)writeSkimNotes:(NSData *)notesData textNotes:(NSString *)textNotes RTFNotes:(NSData *)rtfNotesData atPath:(NSString *)path error:(NSError **)outError;

- (BOOL)removeSkimNotesAtPath:(NSString *)path error:(NSError **)outError;

- (BOOL)hasSkimNotesAtPath:(NSString *)path;

@end


text:
"""
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.

"""

import re

from resource_management.core.logger import Logger
from resource_management.core.exceptions import Fail
from resource_management.core.resources.system import Execute
from resource_management.core import shell
from resource_management.libraries.functions import format
from resource_management.libraries.functions.decorator import retry
from resource_management.libraries.functions import check_process_status
from resource_management.core import ComponentIsNotRunning
from utils import get_dfsadmin_base_command

def pre_rolling_upgrade_shutdown(hdfs_binary):
  """
  Runs the "shutdownDatanode {ipc_address} upgrade" command to shutdown the
  DataNode in preparation for an upgrade. This will then periodically check
  "getDatanodeInfo" to ensure the DataNode has shutdown correctly.
  This function will obtain the Kerberos ticket if security is enabled.
  :param hdfs_binary: name/path of the HDFS binary to use
  :return: Return True if ran ok (even with errors), and False if need to stop the datanode forcefully.
  """
  import params

  Logger.info('DataNode executing "shutdownDatanode" command in preparation for upgrade...')
  if params.security_enabled:
    Execute(params.dn_kinit_cmd, user = params.hdfs_user)

  dfsadmin_base_command = get_dfsadmin_base_command(hdfs_binary)
  command = format('{dfsadmin_base_command} -shutdownDatanode {dfs_dn_ipc_address} upgrade')

  code, output = shell.call(command, user=params.hdfs_user)
  if code != 0:
    # Due to bug HDFS-7533, DataNode may not always shutdown during stack upgrade, and it is necessary to kill it.
    if output is not None and re.search("Shutdown already in progress", output):
      Logger.error("Due to a known issue in DataNode, the command {0} did not work, so will need to shutdown the datanode forcefully.".format(command))
      return False
  return True

def post_upgrade_check(hdfs_binary):
  """
  Verifies that the DataNode has rejoined the cluster. This function will
  obtain the Kerberos ticket if security is enabled.
  :param hdfs_binary: name/path of the HDFS binary to use
  :return:
  """
  import params

  Logger.info("Checking that the DataNode has rejoined the cluster after upgrade...")
  if params.security_enabled:
    Execute(params.dn_kinit_cmd, user=params.hdfs_user)

  # verify that the datanode has started and rejoined the HDFS cluster
  _check_datanode_startup(hdfs_binary)

def is_datanode_process_running():
  import params
  try:
    check_process_status(params.datanode_pid_file)
    return True
  except ComponentIsNotRunning:
    return False

@retry(times=30, sleep_time=30, err_class=Fail) # keep trying for 15 mins
def _check_datanode_startup(hdfs_binary):
  """
  Checks that a DataNode process is running and DataNode is reported as being alive via the
  "hdfs dfsadmin -fs {namenode_address} -report -live" command. Once the DataNode is found to be
  alive this method will return, otherwise it will raise a Fail(...) and retry
  automatically.
  :param hdfs_binary: name/path of the HDFS binary to use
  :return:
  """

  if not is_datanode_process_running():
    Logger.info("DataNode process is not running")
    raise Fail("DataNode process is not running")

  import params
  import socket

  try:
    dfsadmin_base_command = get_dfsadmin_base_command(hdfs_binary)
    command = dfsadmin_base_command + ' -report -live'
    return_code, hdfs_output = shell.call(command, user=params.hdfs_user)
  except:
    raise Fail('Unable to determine if the DataNode has started after upgrade.')

  if return_code == 0:
    hostname = params.hostname.lower()
    hostname_ip =  socket.gethostbyname(params.hostname.lower())
    if hostname in hdfs_output.lower() or hostname_ip in hdfs_output.lower():
      Logger.info("DataNode {0} reports that it has rejoined the cluster.".format(params.hostname))
      return
    else:
      raise Fail("DataNode {0} was not found in the list of live DataNodes".format(params.hostname))

  # return_code is not 0, fail
  raise Fail("Unable to determine if the DataNode has started after upgrade (result code {0})".format(str(return_code)))


text:
package TestCustonReaderAnnoted;

import static org.junit.Assert.assertTrue;

import org.junit.Test;

import TestCustonReaderAnnoted.data.ClassWithMetadata;
import net.sf.esfinge.metadata.AnnotationReader;

public class ProcessorWithContainerTest {

	@Test
	public void validAnnotation() throws Exception {
		AnnotationReader ar = new AnnotationReader();

		Container ct = new Container();

		ct = ar.readingAnnotationsTo(ClassWithMetadata.class, Container.class);

		ExecuteProcessors processor  =(ExecuteProcessors) ct.getInterf().get(0);

		assertTrue(processor.isExistAnnotation());

	}

}


text:
namespace FluentNHibernate.Mapping
{
    /// <summary>
    /// Laziness strategy for relationships
    /// </summary>
    public class Laziness
    {
        /// <summary>
        /// No lazy loading
        /// </summary>
        public static readonly Laziness False = new Laziness("false");

        /// <summary>
        /// Proxy-based lazy-loading
        /// </summary>
        public static readonly Laziness Proxy = new Laziness("proxy");

        /// <summary>
        /// No proxy lazy loading
        /// </summary>
        public static readonly Laziness NoProxy = new Laziness("no-proxy");

        readonly string value;

        public Laziness(string value)
        {
            this.value = value;
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as Laziness);
        }

        public bool Equals(Laziness other)
        {
            if (ReferenceEquals(null, other)) return false;
            if (ReferenceEquals(this, other)) return true;
            return Equals(other.value, value);
        }

        public override int GetHashCode()
        {
            return (value != null ? value.GetHashCode() : 0);
        }

        public override string ToString()
        {
            return value;
        }
    }
}


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <title>Models Sample</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

        <link rel="stylesheet" type="text/css" href="../dojo/dijit/themes/pentaho/pentaho.css"/>

Data API - Data Sources

            This example shows you how to get a list of data sources, and how to get information about the details of a data source.

                        Data Sources:
                        Data Source Info:

                            <select size="15" id="model-list" style="width:200px" onchange="showModelInfo()">
                            </select>

                            Id

                            <input type="text" disabled="true" id="model-id" style="width:300px" value=""/>

                            type

                            <input type="text" disabled="true" id="model-type" style="width:300px" value=""/>

                            Data Source Name

                            <input type="text" disabled="true" id="model-name" style="width:300px" value=""/>

                            Data Source Description

                            <input type="text" disabled="true" id="model-description" style="width:300px" value=""/>

                        <button onclick="loadModels()">Load Data Source List</button>
                        <button onclick="loadModel()">Load Data Source Details</button>

Data Source Capabilities

                        Capability
                        Value

Columns

                        Id
                        Name
                        Description
                        Field Type
                        Data Type
                        Query Element?
                        Alignment
                        Format
                        Agg Type
                        Default Agg Type
                        Available Agg Types
                        Child Of