// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\system\t_atomic.cpp

// 

//

#define	__E32TEST_EXTENSION__

#include <e32test.h>

#include <e32atomics.h>

#include <u32hal.h>

#include "u32std.h"

#include <e32svr.h>

#include <hal.h>

RTest test(_L("T_ATOMIC"));

#include "t_atomic.h"

#ifdef __EPOC32__

RTestAtomic	DD;

#endif

extern "C" {

extern const char* FuncName[];

extern const PFV AtomicFuncPtr[];

extern const PFV ControlFuncPtr[];

extern const TUint FuncAttr[];

}

class TestOverflowTruncate2 : public TDes16Overflow

	{

public:

	virtual void Overflow(TDes16 &aDes);

	};

void TestOverflowTruncate2::Overflow(TDes16& /*aDes*/)

	{

	}

void UPrintf(const char* aFmt, ...)

	{

	// Print to a console screen.

	TestOverflowTruncate2 overflow;

	VA_LIST list;

	VA_START(list, aFmt);

	TBuf8<256> fmtBuf8((const TUint8*)aFmt);

	TBuf<256> buf;

	buf.AppendFormatList(fmtBuf8.Expand(), list, &overflow);

	test.Printf(_L("%S\n"),&buf);

	}

/******************************************************************************

 * Single thread normal operation tests

 ******************************************************************************/

template<class T>

struct TD

	{

	T		i0;

	T		i1;

	T		i2;

	T		i3;

	TInt	iF;

	TInt	iPadding;

	};

struct TDG : public TDGBase

	{

	void Set(const TD<TUint8>	aTD8,	TInt aOrd);

	void Set(const TD<TUint16>	aTD16,	TInt aOrd);

	void Set(const TD<TUint32>	aTD32,	TInt aOrd);

	void Set(const TD<TUint64>	aTD64,	TInt aOrd);

	TInt ExecuteUser();

	TInt ExecuteKernel();

	};

TInt GetAtomicFuncIndex(TInt aFunc, TInt aSize, TInt aOrd)

	{

	test_NotNegative(aFunc);

	test_Compare(aFunc,<,EAtomicFuncN);

	test_NotNegative(aOrd);

	test_Compare(aOrd,<,4);

	aFunc *= 4;

	switch(aSize)

		{

		case 1:	break;

		case 2:	aFunc += INDEXES_PER_SIZE; break;

		case 4:	aFunc += 2*INDEXES_PER_SIZE; break;

		case 8:	aFunc += 3*INDEXES_PER_SIZE; break;

		default: test_Equal(8,aSize); break;

		}

	aFunc += aOrd;

	if (AtomicFuncPtr[aFunc])

		return aFunc;

	return -1;

	}

void TDG::Set(const TD<TUint8> aTD8, TInt aOrd)

	{

	i0 = aTD8.i0;

	i1 = aTD8.i1;

	i2 = aTD8.i2;

	i3 = aTD8.i3;

	iIndex = GetAtomicFuncIndex(aTD8.iF, 1, aOrd);

#ifdef __EXTRA_DEBUG__

	DEBUGPRINT(" 8: iF=%2d aOrd=%1d -> %d", aTD8.iF, aOrd, iIndex);

#endif

	}

void TDG::Set(const TD<TUint16> aTD16, TInt aOrd)

	{

	i0 = aTD16.i0;

	i1 = aTD16.i1;

	i2 = aTD16.i2;

	i3 = aTD16.i3;

	iIndex = GetAtomicFuncIndex(aTD16.iF, 2, aOrd);

#ifdef __EXTRA_DEBUG__

	DEBUGPRINT("16: iF=%2d aOrd=%1d -> %d", aTD16.iF, aOrd, iIndex);

#endif

	}

void TDG::Set(const TD<TUint32> aTD32, TInt aOrd)

	{

	i0 = aTD32.i0;

	i1 = aTD32.i1;

	i2 = aTD32.i2;

	i3 = aTD32.i3;

	iIndex = GetAtomicFuncIndex(aTD32.iF, 4, aOrd);

#ifdef __EXTRA_DEBUG__

	DEBUGPRINT("32: iF=%2d aOrd=%1d -> %d", aTD32.iF, aOrd, iIndex);

#endif

	}

void TDG::Set(const TD<TUint64> aTD64, TInt aOrd)

	{

	i0 = aTD64.i0;

	i1 = aTD64.i1;

	i2 = aTD64.i2;

	i3 = aTD64.i3;

	iIndex = GetAtomicFuncIndex(aTD64.iF, 8, aOrd);

#ifdef __EXTRA_DEBUG__

	DEBUGPRINT("64: iF=%2d aOrd=%1d -> %d", aTD64.iF, aOrd, iIndex);

#endif

	}

TInt TDG::ExecuteUser()

	{

	return Execute();

	}

#ifdef __EPOC32__

TInt TDG::ExecuteKernel()

	{

	return DD.TDGExecuteK(*this);

	}

#endif

#define	DCL_TEST_BLOCK(type,name)			\

	static const TD<type> name[] =

#define	DCL_TEST1(type,func,a0)				\

	{	(type)(a0),	(type)(0),	(type)(0),	(type)(0),	(EAtomicFunc##func),	0	}

#define	DCL_TEST2(type,func,a0,a1)			\

	{	(type)(a0),	(type)(a1),	(type)(0),	(type)(0),	(EAtomicFunc##func),	0	}

#define	DCL_TEST3(type,func,a0,a1,a2)		\

	{	(type)(a0),	(type)(a1),	(type)(a2),	(type)(0),	(EAtomicFunc##func),	0	}

#define	DCL_TEST4(type,func,a0,a1,a2,a3)	\

	{	(type)(a0),	(type)(a1),	(type)(a2),	(type)(a3),	(EAtomicFunc##func),	0	}

DCL_TEST_BLOCK(TUint8,TestData8)

	{

	DCL_TEST1(TUint8,	LOAD,	0x00),

	DCL_TEST1(TUint8,	LOAD,	0xFF),

	DCL_TEST2(TUint8,	STORE,	0xBB, 0x00),

	DCL_TEST2(TUint8,	STORE,	0xBB, 0xFF),

	DCL_TEST2(TUint8,	SWP,	0xBB, 0x00),

	DCL_TEST2(TUint8,	SWP,	0xBB, 0xFF),

	DCL_TEST2(TUint8,	SWP,	0x55, 0x00),

	DCL_TEST2(TUint8,	SWP,	0x55, 0xFF),

	DCL_TEST2(TUint8,	ADD,	0x00, 0x01),

	DCL_TEST2(TUint8,	ADD,	0xFF, 0x01),

	DCL_TEST2(TUint8,	ADD,	0xFE, 0x01),

	DCL_TEST2(TUint8,	ADD,	0xFE, 0x02),

	DCL_TEST2(TUint8,	ADD,	0xFE, 0x03),

	DCL_TEST2(TUint8,	ADD,	0x12, 0x23),

	DCL_TEST2(TUint8,	AND,	0x00, 0x01),

	DCL_TEST2(TUint8,	AND,	0xFF, 0x01),

	DCL_TEST2(TUint8,	AND,	0xFE, 0x01),

	DCL_TEST2(TUint8,	AND,	0xFE, 0xFF),

	DCL_TEST2(TUint8,	AND,	0xFE, 0x03),

	DCL_TEST2(TUint8,	AND,	0x5F, 0xAF),

	DCL_TEST2(TUint8,	IOR,	0x00, 0x01),

	DCL_TEST2(TUint8,	IOR,	0xFF, 0x01),

	DCL_TEST2(TUint8,	IOR,	0xFE, 0x01),

	DCL_TEST2(TUint8,	IOR,	0x0D, 0x5F),

	DCL_TEST2(TUint8,	IOR,	0x30, 0x03),

	DCL_TEST2(TUint8,	IOR,	0x5F, 0xAF),

	DCL_TEST2(TUint8,	XOR,	0x00, 0x01),

	DCL_TEST2(TUint8,	XOR,	0xFF, 0x01),

	DCL_TEST2(TUint8,	XOR,	0xFE, 0x01),

	DCL_TEST2(TUint8,	XOR,	0xFE, 0xFF),

	DCL_TEST2(TUint8,	XOR,	0xFE, 0x03),

	DCL_TEST2(TUint8,	XOR,	0x5F, 0xAF),

	DCL_TEST3(TUint8,	AXO,	0x00, 0xFF,	0x00),

	DCL_TEST3(TUint8,	AXO,	0x00, 0xFF,	0x33),

	DCL_TEST3(TUint8,	AXO,	0x00, 0xFF,	0x7D),

	DCL_TEST3(TUint8,	AXO,	0x00, 0xFF,	0xBB),

	DCL_TEST3(TUint8,	AXO,	0xAA, 0x00,	0x00),

	DCL_TEST3(TUint8,	AXO,	0xAA, 0x00,	0x33),

	DCL_TEST3(TUint8,	AXO,	0xAA, 0x00,	0x7D),

	DCL_TEST3(TUint8,	AXO,	0xAA, 0x00,	0xBB),

	DCL_TEST3(TUint8,	AXO,	0xAA, 0x33,	0xF0),

	DCL_TEST3(TUint8,	AXO,	0xAA, 0x33,	0x0F),

	DCL_TEST3(TUint8,	AXO,	0xAA, 0xCC,	0xF0),

	DCL_TEST3(TUint8,	AXO,	0xAA, 0xCC,	0x0F),

	DCL_TEST3(TUint8,	CAS,	0x00, 0xFF,	0xEE),

	DCL_TEST3(TUint8,	CAS,	0x00, 0x01,	0x11),

	DCL_TEST3(TUint8,	CAS,	0x00, 0x00,	0xEE),

	DCL_TEST3(TUint8,	CAS,	0x00, 0x00,	0x23),

	DCL_TEST3(TUint8,	CAS,	0x2A, 0xFF,	0x2B),

	DCL_TEST3(TUint8,	CAS,	0x2A, 0x01,	0x2B),

	DCL_TEST3(TUint8,	CAS,	0x2A, 0x2A,	0x2B),

	DCL_TEST3(TUint8,	CAS,	0x2A, 0x2A,	0x3B),

	DCL_TEST4(TUint8,	TAU,	0x00, 0x00,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAU,	0x01, 0x00,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAU,	0xFF, 0x00,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAU,	0x00, 0x01,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAU,	0x01, 0x01,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAU,	0x02, 0x01,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAU,	0xFF, 0x01,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAU,	0xFE, 0xFE,	0x23, 0x0B),

	DCL_TEST4(TUint8,	TAU,	0xEE, 0xFE,	0x23, 0x0B),

	DCL_TEST4(TUint8,	TAU,	0xFF, 0xFE,	0x23, 0x0B),

	DCL_TEST4(TUint8,	TAU,	0x00, 0xFE,	0x23, 0x0B),

	DCL_TEST4(TUint8,	TAU,	0xFE, 0xFE,	0x80, 0x7F),

	DCL_TEST4(TUint8,	TAU,	0xEE, 0xFE,	0x80, 0x7F),

	DCL_TEST4(TUint8,	TAU,	0xFF, 0xFE,	0x80, 0x7F),

	DCL_TEST4(TUint8,	TAU,	0x00, 0xFE,	0x80, 0x7F),

	DCL_TEST4(TUint8,	TAU,	0xFE, 0x80,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAU,	0x7F, 0x80,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAU,	0x80, 0x80,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAU,	0x81, 0x80,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAU,	0x00, 0x80,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAU,	0x7E, 0x7F,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAU,	0x7F, 0x7F,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAU,	0x80, 0x7F,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAU,	0x81, 0x7F,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAU,	0x00, 0x7F,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAS,	0x00, 0x00,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAS,	0x01, 0x00,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAS,	0xFF, 0x00,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAS,	0x00, 0x01,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAS,	0x01, 0x01,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAS,	0x02, 0x01,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAS,	0xFF, 0x01,	0x02, 0x03),

	DCL_TEST4(TUint8,	TAS,	0xFE, 0xFE,	0x23, 0x0B),

	DCL_TEST4(TUint8,	TAS,	0xEE, 0xFE,	0x23, 0x0B),

	DCL_TEST4(TUint8,	TAS,	0xFF, 0xFE,	0x23, 0x0B),

	DCL_TEST4(TUint8,	TAS,	0x00, 0xFE,	0x23, 0x0B),

	DCL_TEST4(TUint8,	TAS,	0xFE, 0xFE,	0x80, 0x7F),

	DCL_TEST4(TUint8,	TAS,	0xEE, 0xFE,	0x80, 0x7F),

	DCL_TEST4(TUint8,	TAS,	0xFF, 0xFE,	0x80, 0x7F),

	DCL_TEST4(TUint8,	TAS,	0x00, 0xFE,	0x80, 0x7F),

	DCL_TEST4(TUint8,	TAS,	0xFE, 0x80,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAS,	0x7F, 0x80,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAS,	0x80, 0x80,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAS,	0x81, 0x80,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAS,	0x00, 0x80,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAS,	0x7E, 0x7F,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAS,	0x7F, 0x7F,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAS,	0x80, 0x7F,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAS,	0x81, 0x7F,	0x81, 0x7E),

	DCL_TEST4(TUint8,	TAS,	0x00, 0x7F,	0x81, 0x7E)

	};

DCL_TEST_BLOCK(TUint16,TestData16)

	{

	DCL_TEST1(TUint16,	LOAD,	0x0055),

	DCL_TEST1(TUint16,	LOAD,	0xFFAA),

	DCL_TEST2(TUint16,	STORE,	0xBBBB, 0x0055),

	DCL_TEST2(TUint16,	STORE,	0xBBBB, 0xFFAA),

	DCL_TEST2(TUint16,	SWP,	0xBBCC, 0x0055),

	DCL_TEST2(TUint16,	SWP,	0xBBCC, 0xFFAA),

	DCL_TEST2(TUint16,	SWP,	0x55AA, 0x0033),

	DCL_TEST2(TUint16,	SWP,	0x55AA, 0xFFCC),

	DCL_TEST2(TUint16,	ADD,	0x0000, 0x0001),

	DCL_TEST2(TUint16,	ADD,	0xFFFF, 0x0001),

	DCL_TEST2(TUint16,	ADD,	0xFFFE, 0x0001),

	DCL_TEST2(TUint16,	ADD,	0xFFFE, 0x0002),

	DCL_TEST2(TUint16,	ADD,	0xFFFE, 0x0003),

	DCL_TEST2(TUint16,	ADD,	0x0012, 0x0023),

	DCL_TEST2(TUint16,	ADD,	0x0012, 0xBCFF),

	DCL_TEST2(TUint16,	AND,	0x0000, 0x0001),

	DCL_TEST2(TUint16,	AND,	0xFFFF, 0x0001),

	DCL_TEST2(TUint16,	AND,	0xFFFE, 0x0001),

	DCL_TEST2(TUint16,	AND,	0xFFFE, 0xFFFF),

	DCL_TEST2(TUint16,	AND,	0xFFFE, 0x0F03),

	DCL_TEST2(TUint16,	AND,	0xBC5F, 0x14AF),

	DCL_TEST2(TUint16,	IOR,	0x0000, 0x0001),

	DCL_TEST2(TUint16,	IOR,	0xFFFF, 0x0001),

	DCL_TEST2(TUint16,	IOR,	0xFFFE, 0x0001),

	DCL_TEST2(TUint16,	IOR,	0x000D, 0x005F),

	DCL_TEST2(TUint16,	IOR,	0x8030, 0x0803),

	DCL_TEST2(TUint16,	IOR,	0x145F, 0x56AF),

	DCL_TEST2(TUint16,	XOR,	0x0000, 0x0001),

	DCL_TEST2(TUint16,	XOR,	0xFFFF, 0x0001),

	DCL_TEST2(TUint16,	XOR,	0xFFFE, 0x0001),

	DCL_TEST2(TUint16,	XOR,	0xFFFE, 0xFFFF),

	DCL_TEST2(TUint16,	XOR,	0xFFFE, 0x0003),

	DCL_TEST2(TUint16,	XOR,	0x145F, 0xBCAF),

	DCL_TEST3(TUint16,	AXO,	0x0000, 0xFFFF,	0x0000),

	DCL_TEST3(TUint16,	AXO,	0x0000, 0xFFFF,	0x6633),

	DCL_TEST3(TUint16,	AXO,	0x0000, 0xFFFF,	0x827D),

	DCL_TEST3(TUint16,	AXO,	0x0000, 0xFFFF,	0xCCBB),

	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x0000,	0x0000),

	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x0000,	0x6633),

	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x0000,	0x827D),

	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x0000,	0xCCBB),

	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0xCC33,	0x0FF0),

	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0xCC33,	0xF00F),

	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x33CC,	0x0FF0),

	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x33CC,	0xF00F),

	DCL_TEST3(TUint16,	CAS,	0x0000, 0x00FF,	0x99EE),

	DCL_TEST3(TUint16,	CAS,	0x0000, 0x0001,	0x7711),

	DCL_TEST3(TUint16,	CAS,	0x0000, 0x0000,	0x99EE),

	DCL_TEST3(TUint16,	CAS,	0x0000, 0x0000,	0x1123),

	DCL_TEST3(TUint16,	CAS,	0x832A, 0xFFFF,	0x832B),

	DCL_TEST3(TUint16,	CAS,	0x832A, 0x0001,	0x832B),

	DCL_TEST3(TUint16,	CAS,	0x832A, 0x822A,	0x832B),

	DCL_TEST3(TUint16,	CAS,	0x832A, 0x832B,	0x943B),

	DCL_TEST3(TUint16,	CAS,	0x832A, 0x832A,	0x832B),

	DCL_TEST3(TUint16,	CAS,	0x832A, 0x832A,	0x943B),

	DCL_TEST4(TUint16,	TAU,	0x0000, 0x0000,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAU,	0x0001, 0x0000,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAU,	0xFFFF, 0x0000,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAU,	0x0000, 0x0001,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAU,	0x0001, 0x0001,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAU,	0x0002, 0x0001,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAU,	0xFFFF, 0x0001,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAU,	0xFFFE, 0xFFFE,	0x1023, 0x000B),

	DCL_TEST4(TUint16,	TAU,	0xFFEE, 0xFFFE,	0x1423, 0x000B),

	DCL_TEST4(TUint16,	TAU,	0xFFFF, 0xFFFE,	0x1423, 0x000B),

	DCL_TEST4(TUint16,	TAU,	0x0000, 0xFFFE,	0x1423, 0x000B),

	DCL_TEST4(TUint16,	TAU,	0xFFFE, 0xFFFE,	0x8000, 0x7FFF),

	DCL_TEST4(TUint16,	TAU,	0xFFEE, 0xFFFE,	0x8000, 0x7FFF),

	DCL_TEST4(TUint16,	TAU,	0xFFFF, 0xFFFE,	0x8000, 0x7FFF),

	DCL_TEST4(TUint16,	TAU,	0x0000, 0xFFFE,	0x8000, 0x7FFF),

	DCL_TEST4(TUint16,	TAU,	0xFFFE, 0x8000,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAU,	0x7FFF, 0x8000,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAU,	0x8000, 0x8000,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAU,	0x8001, 0x8000,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAU,	0x0000, 0x8000,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAU,	0x7FFE, 0x7FFF,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAU,	0x7FFF, 0x7FFF,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAU,	0x8000, 0x7FFF,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAU,	0x8001, 0x7FFF,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAU,	0x0000, 0x7FFF,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAS,	0x0000, 0x0000,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAS,	0x0001, 0x0000,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAS,	0xFFFF, 0x0000,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAS,	0x0000, 0x0001,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAS,	0x0001, 0x0001,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAS,	0x0002, 0x0001,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAS,	0xFFFF, 0x0001,	0x0002, 0x0003),

	DCL_TEST4(TUint16,	TAS,	0xFFFE, 0xFFFE,	0x1023, 0x000B),

	DCL_TEST4(TUint16,	TAS,	0xFFEE, 0xFFFE,	0x1423, 0x000B),

	DCL_TEST4(TUint16,	TAS,	0xFFFF, 0xFFFE,	0x1423, 0x000B),

	DCL_TEST4(TUint16,	TAS,	0x0000, 0xFFFE,	0x1423, 0x000B),

	DCL_TEST4(TUint16,	TAS,	0xFFFE, 0xFFFE,	0x8000, 0x7FFF),

	DCL_TEST4(TUint16,	TAS,	0xFFEE, 0xFFFE,	0x8000, 0x7FFF),

	DCL_TEST4(TUint16,	TAS,	0xFFFF, 0xFFFE,	0x8000, 0x7FFF),

	DCL_TEST4(TUint16,	TAS,	0x0000, 0xFFFE,	0x8000, 0x7FFF),

	DCL_TEST4(TUint16,	TAS,	0xFFFE, 0x8000,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAS,	0x7FFF, 0x8000,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAS,	0x8000, 0x8000,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAS,	0x8001, 0x8000,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAS,	0x0000, 0x8000,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAS,	0x7FFE, 0x7FFF,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAS,	0x7FFF, 0x7FFF,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAS,	0x8000, 0x7FFF,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAS,	0x8001, 0x7FFF,	0x8001, 0x7FFE),

	DCL_TEST4(TUint16,	TAS,	0x0000, 0x7FFF,	0x8001, 0x7FFE)

	};

DCL_TEST_BLOCK(TUint32,TestData32)

	{

	DCL_TEST1(TUint32,	LOAD,	0x00334455),

	DCL_TEST1(TUint32,	LOAD,	0xFFCCBBAA),

	DCL_TEST2(TUint32,	STORE,	0xBBBBBBBB, 0x00334455),

	DCL_TEST2(TUint32,	STORE,	0xBBBBBBBB, 0xFFCCBBAA),

	DCL_TEST2(TUint32,	SWP,	0xBB1234CC, 0x00EDCB55),

	DCL_TEST2(TUint32,	SWP,	0xBB1234CC, 0xFF9876AA),

	DCL_TEST2(TUint32,	SWP,	0x551971AA, 0x00112233),

	DCL_TEST2(TUint32,	SWP,	0x551971AA, 0xFFEEDDCC),

	DCL_TEST2(TUint32,	ADD,	0x00000000, 0x00000001),

	DCL_TEST2(TUint32,	ADD,	0xFFFFFFFF, 0x00000001),

	DCL_TEST2(TUint32,	ADD,	0xFFFFFFFE, 0x00000001),

	DCL_TEST2(TUint32,	ADD,	0xFFFFFFFE, 0x00000002),

	DCL_TEST2(TUint32,	ADD,	0xFFFFFFFE, 0x00000003),

	DCL_TEST2(TUint32,	ADD,	0x00009912, 0x00000023),

	DCL_TEST2(TUint32,	ADD,	0x00009912, 0x4937BCFF),

	DCL_TEST2(TUint32,	AND,	0x00000000, 0x00000001),

	DCL_TEST2(TUint32,	AND,	0xFFFFFFFF, 0x00000001),

	DCL_TEST2(TUint32,	AND,	0xFFFFFFFE, 0x00000001),

	DCL_TEST2(TUint32,	AND,	0xFFFFFFFE, 0xFFFFFFFF),

	DCL_TEST2(TUint32,	AND,	0xFFFFFFFE, 0x00000F03),

	DCL_TEST2(TUint32,	AND,	0xEDCBBC5F, 0xDCBA14AF),

	DCL_TEST2(TUint32,	IOR,	0x00000000, 0x00000001),

	DCL_TEST2(TUint32,	IOR,	0xFFFFFFFF, 0x00000001),

	DCL_TEST2(TUint32,	IOR,	0xFFFFFFFE, 0x00000001),

	DCL_TEST2(TUint32,	IOR,	0x0000000D, 0x0000005F),

	DCL_TEST2(TUint32,	IOR,	0x80000030, 0x00000803),

	DCL_TEST2(TUint32,	IOR,	0x89AB145F, 0x415256AF),

	DCL_TEST2(TUint32,	XOR,	0x00000000, 0x00000001),

	DCL_TEST2(TUint32,	XOR,	0xFFFFFFFF, 0x00000001),

	DCL_TEST2(TUint32,	XOR,	0xFFFFFFFE, 0x00000001),

	DCL_TEST2(TUint32,	XOR,	0xFFFFFFFE, 0xFFFFFFFF),

	DCL_TEST2(TUint32,	XOR,	0xFFFFFFFE, 0x00000003),

	DCL_TEST2(TUint32,	XOR,	0x89AB145F, 0x4152BCAF),

	DCL_TEST3(TUint32,	AXO,	0x00000000, 0xFFFFFFFF,	0x00000000),

	DCL_TEST3(TUint32,	AXO,	0x00000000, 0xFFFFFFFF,	0x99CC6633),

	DCL_TEST3(TUint32,	AXO,	0x00000000, 0xFFFFFFFF,	0x8000027D),

	DCL_TEST3(TUint32,	AXO,	0x00000000, 0xFFFFFFFF,	0xEEDDCCBB),

	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x00000000,	0x00000000),

	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x00000000,	0x99CC6633),

	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x00000000,	0x8000027D),

	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x00000000,	0xEEDDCCBB),

	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x9966CC33,	0x0FF00FF0),

	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x9966CC33,	0xF00FF00F),

	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x669933CC,	0x0FF00FF0),

	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x669933CC,	0xF00FF00F),

	DCL_TEST3(TUint32,	CAS,	0x00000000, 0x000000FF,	0x99ABCDEE),

	DCL_TEST3(TUint32,	CAS,	0x00000000, 0x00000001,	0x7FFFF711),

	DCL_TEST3(TUint32,	CAS,	0x00000000, 0x00000000,	0x99ABCDEE),

	DCL_TEST3(TUint32,	CAS,	0x00000000, 0x00000000,	0x11234567),

	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0xFFFFFFFF,	0x8000032B),

	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0x00000001,	0x8000032B),

	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0x8000022A,	0x8000032B),

	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0x8000032B,	0x943BFCD1),

	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0x8000032A,	0x8000032B),

	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0x8000032A,	0x943BFCD1),

	DCL_TEST4(TUint32,	TAU,	0x00000000, 0x00000000,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAU,	0x00000001, 0x00000000,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFF, 0x00000000,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAU,	0x00000000, 0x00000001,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAU,	0x00000001, 0x00000001,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAU,	0x00000002, 0x00000001,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFF, 0x00000001,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFE, 0xFFFFFFFE,	0x1023144F, 0x0000000B),

	DCL_TEST4(TUint32,	TAU,	0xFFFFFFEE, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFF, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

	DCL_TEST4(TUint32,	TAU,	0x00000000, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFE, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

	DCL_TEST4(TUint32,	TAU,	0xFFFFFFEE, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFF, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

	DCL_TEST4(TUint32,	TAU,	0x00000000, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFE, 0x80000000,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAU,	0x7FFFFFFF, 0x80000000,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAU,	0x80000000, 0x80000000,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAU,	0x80000001, 0x80000000,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAU,	0x00000000, 0x80000000,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAU,	0x7FFFFFFE, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAU,	0x7FFFFFFF, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAU,	0x80000000, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAU,	0x80000001, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAU,	0x00000000, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAS,	0x00000000, 0x00000000,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAS,	0x00000001, 0x00000000,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFF, 0x00000000,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAS,	0x00000000, 0x00000001,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAS,	0x00000001, 0x00000001,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAS,	0x00000002, 0x00000001,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFF, 0x00000001,	0x00000002, 0x00000003),

	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFE, 0xFFFFFFFE,	0x1023144F, 0x0000000B),

	DCL_TEST4(TUint32,	TAS,	0xFFFFFFEE, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFF, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

	DCL_TEST4(TUint32,	TAS,	0x00000000, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFE, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

	DCL_TEST4(TUint32,	TAS,	0xFFFFFFEE, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFF, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

	DCL_TEST4(TUint32,	TAS,	0x00000000, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFE, 0x80000000,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAS,	0x7FFFFFFF, 0x80000000,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAS,	0x80000000, 0x80000000,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAS,	0x80000001, 0x80000000,	0x80000001, 0x7FFFFFFE),

	DCL_TEST4(TUint32,	TAS,	0x00000000, 0x80000000,	0x80000001, 0x7FFFFFFE),