// 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\demandpaging\t_chunkcreate.cpp

 // 

 //

 //

 #define __E32TEST_EXTENSION__

 #include <e32test.h>

 #include <dptest.h>

 #include <e32hal.h>

 #include <u32exec.h>

 #include <e32svr.h>

 #include <e32panic.h>

 #include "u32std.h"

 #include "t_dpcmn.h"

 _LIT(KGlobalChunkName, "TestChunk");

 enum

 	{

 	ECreateNormal,

 	ECreateCode,

 	ECreateGlobal,

 	ECreateLocalDE,

 	ECreateGlobalDE,

 	ECreateLocalDC,

 	ECreateGlobalDC,

 	};

 enum

 	{

 	EPagingUnspec,	// Has to be first as can't clear back to unspecified.

 	EPagingOn,

 	EPagingOff,

 	EPagingNumberAttribs,

 	};

 void VerifyChunkPaged(RChunk& aChunk, TBool aPaged, TInt aR)

 	{

 	UpdatePaged(aPaged);

 	test_KErrNone(aR);

 	test.Printf(_L("aPaged = %d, aChunk.IsPaged() = %d\n"), aPaged, aChunk.IsPaged());

 	test_Equal(aPaged, aChunk.IsPaged());

 	// Uses same name for global chunks so needs to be fully closed before next call

 	CLOSE_AND_WAIT(aChunk);

 	}

 void VerifyChunkPaged(TChunkCreateInfo& aCreateInfo)

 	{

 	TBool paged = EFalse;

 	for (TInt i = 0; i < EPagingNumberAttribs; i++)

 		{

 		switch(i)

 			{

 			case EPagingUnspec :

 				paged = gProcessPaged;	// Should default to process's paged status.

 				test.Printf(_L("Should default to process's paged status\n"));

 				break;

 			case EPagingOn :

 				aCreateInfo.SetPaging(TChunkCreateInfo::EPaged);

 				paged = ETrue;

 				test.Printf(_L("Paging should be on\n"));

 				break;

 			case EPagingOff :

 				aCreateInfo.SetPaging(TChunkCreateInfo::EUnpaged);

 				paged = EFalse;

 				test.Printf(_L("Paging should be off\n"));

 				break;

 			}

 		RChunk chunk;

 		TInt r = chunk.Create(aCreateInfo);

 		VerifyChunkPaged(chunk, paged, r);

 		}

 	}

 TInt PanicChunkCreate(TAny* aCreateInfo)

 	{

 	TChunkCreateInfo createInfo((*(TChunkCreateInfo*) aCreateInfo));

 	gChunk.Create(createInfo);

 	return KErrGeneral; // Should never reach here

 	}

 void TestPanicChunkCreate1(TInt aType, TInt aSize, TInt aMaxSize, TInt aPanicCode)

 	{

 	TChunkCreateInfo createInfo;

 	switch (aType)

 		{

 		case ECreateNormal:

 			createInfo.SetNormal(aSize, aMaxSize);

 			break;

 		case ECreateCode:

 			createInfo.SetCode(aSize, aMaxSize);

 			break;

 		case ECreateGlobal:

 			createInfo.SetNormal(aSize, aMaxSize);

 			createInfo.SetGlobal(KGlobalChunkName);

 			break;

 		}

 	RThread thread;

 	test_KErrNone(thread.Create(_L("Panic CreateChunk"), PanicChunkCreate, KDefaultStackSize, KMinHeapSize, 

 														KMinHeapSize,  (TAny*) &createInfo));

 	test_KErrNone(TestThreadExit(thread, EExitPanic, aPanicCode));

 	}

 void TestPanicChunkCreate2(TInt aType, TInt aBottom, TInt aTop, TInt aMaxSize, TInt aPanicCode)

 	{

 	TChunkCreateInfo createInfo;

 	switch (aType)

 		{		

 		case ECreateLocalDE:

 			createInfo.SetDoubleEnded(aBottom, aTop, aMaxSize);

 			break;

 		case ECreateGlobalDE:

 			createInfo.SetDoubleEnded(aBottom, aTop, aMaxSize);

 			createInfo.SetGlobal(KGlobalChunkName);

 			break;

 		case ECreateLocalDC:

 			createInfo.SetDisconnected(aBottom, aTop, aMaxSize);

 			break;

 		case ECreateGlobalDC:

 			createInfo.SetDisconnected(aBottom, aTop, aMaxSize);

 			createInfo.SetGlobal(KGlobalChunkName);

 			break;

 		}

 	RThread thread;

 	test_KErrNone(thread.Create(_L("Panic CreateChunk"), PanicChunkCreate, KDefaultStackSize, KMinHeapSize, 

 														KMinHeapSize,  (TAny*) &createInfo));

 	test_KErrNone(TestThreadExit(thread, EExitPanic, aPanicCode));

 	}

 // 

 // TestLocalChunk

 //

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID			KBASE-T_CHUNKCREATE-xxxx

 //! @SYMTestType			UT

 //! @SYMPREQ				PREQ1954

 //! @SYMTestCaseDesc		Verify the local chunk creation implementation.

 //! @SYMTestActions			

 //! 1.	Create a local chunk and specify the following paging options. 

 //!		Following this, check the paging status of the chunk by calling IsPaged

 //!		a.	Not specified

 //!		b.	Paged

 //!		c.	Unpaged

 //! 2.	Create a local chunk and specify aMaxSize to be negative

 //! 3.	Create a local chunk and specify aSize to be negative

 //! 4.	Create a local chunk and specify aMaxSize to be less than aSize.

 //!

 //! @SYMTestExpectedResults 

 //! 1.	The following results are expected:

 //!		a.	The chunk should take on the paging status of the process

 //!		b.	ETrue

 //!		c.	EFalse

 //! 2.	Panic USER99

 //! 3.	Panic USER100

 //! 4.	Panic USER101

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 void TestLocalChunk()

 	{

 	test.Start(_L("Test RChunk::CreateLocal - paging attributes"));

 		{

 		TChunkCreateInfo createInfo;

 		createInfo.SetNormal(gPageSize, gPageSize);

 		VerifyChunkPaged(createInfo);

 		// Test default create method

 		TInt r = gChunk.CreateLocal(gPageSize, gPageSize);

 		VerifyChunkPaged(gChunk, gProcessPaged, r);

 		}

 	test.Next(_L("Test RChunk::CreateLocal - invalid max size"));

 	TestPanicChunkCreate1(ECreateNormal, gPageSize, -1, EChkCreateMaxSizeNegative);

 	test.Next(_L("Test RChunk::CreateLocal - invalid  size"));

 	TestPanicChunkCreate1(ECreateNormal, -1, gPageSize, EChkCreateSizeNotPositive);

 	test.Next(_L("Test RChunk::CreateLocal - aSize > aMaxSize"));

 	TestPanicChunkCreate1(ECreateNormal, gPageSize << 1, gPageSize, EChkCreateMaxLessThanMin);

 	test.End();

 	}

 // 

 // TestCodeChunk

 //

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID			KBASE-T_CHUNKCREATE-xxxx

 //! @SYMTestType			UT

 //! @SYMPREQ				PREQ1954

 //! @SYMTestCaseDesc		Verify the user code chunk creation implementation

 //! @SYMTestActions			

 //! 1.	Create a user code chunk and specify the following paging options. 

 //!		Following this check the paging status of the chunk by calling IsPaged().

 //!		a.	Not specified

 //!		b.	Paged

 //!		c.	Unpaged

 //! 2.	Create a user code chunk and specify aMaxSize to be negative

 //! 3.	Create a user code chunk and specify aSize to be negative

 //! 4.	Create a user code chunk and specify aMaxSize to be less than aSize.

 //!

 //! @SYMTestExpectedResults 

 //! 1.	The following results are expected:

 //!		a.	The chunk should take on the paging status of the process

 //!		b.	ETrue

 //!		c.	EFalse

 //! 2.	Panic USER99

 //! 3.	Panic USER100

 //! 4.	Panic USER101

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 void TestCodeChunk()

 	{

 	test.Start(_L("Test RChunk::CreateLocalCode - paging attributes"));

 		{

 		TChunkCreateInfo createInfo;

 		createInfo.SetCode(gPageSize, gPageSize);

 		VerifyChunkPaged(createInfo);

 		// Test default create method

 		TInt r = gChunk.CreateLocal(gPageSize, gPageSize);

 		VerifyChunkPaged(gChunk, gProcessPaged, r);

 		}

 	test.Next(_L("Test RChunk::CreateLocalCode - invalid max size"));

 	TestPanicChunkCreate1(ECreateCode, gPageSize, -1, EChkCreateMaxSizeNegative);

 	test.Next(_L("Test RChunk::CreateLocalCode - invalid  size"));

 	TestPanicChunkCreate1(ECreateCode, -1, gPageSize, EChkCreateSizeNotPositive);

 	test.Next(_L("Test RChunk::CreateLocalCode - aSize > aMaxSize"));

 	TestPanicChunkCreate1(ECreateCode, gPageSize << 1, gPageSize, EChkCreateMaxLessThanMin);

 	test.End();

 	}

 // 

 // TestGlobalChunk

 //

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID			KBASE-T_CHUNKCREATE-xxxx

 //! @SYMTestType			UT

 //! @SYMPREQ				PREQ1954

 //! @SYMTestCaseDesc		Verify the global chunk creation implementation

 //! @SYMTestActions			

 //! 1.	Create a global chunk and specify the following paging options. 

 //!		Following this check the paging status of the chunk by calling IsPaged().

 //!		a.	Not specified

 //!		b.	Paged

 //!		c.	Unpaged

 //! 1.	Create a global chunk and specify aMaxSize to be negative

 //! 2.	Create a global chunk and specify aSize to be negative

 //! 3.	Create a global chunk and specify aMaxSize to be less than aSize.

 //!

 //! @SYMTestExpectedResults 

 //! 1.	The following results are expected:

 //!		a.	The chunk should take on the paging status of the process

 //!		b.	ETrue

 //!		c.	EFalse

 //! 2.	Panic USER99

 //! 3.	Panic USER100

 //! 4.	Panic USER101

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 void TestGlobalChunk()

 	{

 	test.Start(_L("Test RChunk::CreateGlobal - paging attributes"));

 		{

 		TChunkCreateInfo createInfo;

 		createInfo.SetNormal(gPageSize, gPageSize);

 		createInfo.SetGlobal(KGlobalChunkName);

 		VerifyChunkPaged(createInfo);

 		// Test default create method

 		TInt r = gChunk.CreateLocal(gPageSize, gPageSize);

 		VerifyChunkPaged(gChunk, gProcessPaged, r);

 		}

 	test.Next(_L("Test RChunk::CreateGlobal - invalid max size"));

 	TestPanicChunkCreate1(ECreateGlobal, gPageSize, -1, EChkCreateMaxSizeNegative);

 	test.Next(_L("Test RChunk::CreateGlobal - invalid  size"));

 	TestPanicChunkCreate1(ECreateGlobal, -1, gPageSize, EChkCreateSizeNotPositive);

 	test.Next(_L("Test RChunk::CreateGlobal - aSize > aMaxSize"));

 	TestPanicChunkCreate1(ECreateGlobal, gPageSize << 1, gPageSize, EChkCreateMaxLessThanMin);

 	test.End();

 	}

 // 

 // TestLocDEChunk

 //

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID			KBASE-T_CHUNKCREATE-xxxx

 //! @SYMTestType			UT

 //! @SYMPREQ				PREQ1954

 //! @SYMTestCaseDesc		Verify the local double ended chunk creation implementation

 //! @SYMTestActions			

 //! 1.	Create a local, double ended, chunk and specify the following paging options. 

 //!		Following this check the paging status of the chunk by calling IsPaged().

 //!		a.	Not specified

 //!		b.	Paged

 //!		c.	Unpaged

 //! 2.	Create a local, double ended, chunk and specify aMaxSize to be negative

 //! 3.	Create a local, double ended, chunk and specify aInitialBottom to be negative

 //! 4.	Create a local, double ended, chunk and specify aInitialTop to be negative.

 //! 5.	Create a local, double ended, chunk and specify aInitialBottom to be greater than aInitialTop.

 //! 6.	Create a local, double ended, chunk and specify aInitialTop to be greater than aMaxSize.

 //!

 //! @SYMTestExpectedResults 

 //! 1.	1.	The following results are expected:

 //!		a.	The chunk should take on the paging status of the process

 //!		b.	ETrue

 //!		c.	EFalse

 //! 2.	Panic USER99

 //! 3.	Panic USER120

 //! 4.	Panic USER121

 //! 5.	Panic USER122

 //! 6.	Panic USER123

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 void TestLocDEChunk()

 	{

 	test.Start(_L("Test RChunk::CreateDoubleEndedLocal - paging attributes"));

 		{

 		TChunkCreateInfo createInfo;

 		createInfo.SetDoubleEnded(0, gPageSize, gPageSize);

 		VerifyChunkPaged(createInfo);

 		// Test default create method

 		TInt r = gChunk.CreateDoubleEndedLocal(0, gPageSize, gPageSize);

 		VerifyChunkPaged(gChunk, gProcessPaged, r);

 		}

 	test.Next(_L("Test RChunk::CreateDoubleEndedLocal - invalid max size"));

 	TestPanicChunkCreate2(ECreateLocalDE, 0, gPageSize, -1, EChkCreateMaxSizeNegative);

 	test.Next(_L("Test RChunk::CreateDoubleEndedLocal - invalid bottom"));

 	TestPanicChunkCreate2(ECreateLocalDE, -1, gPageSize, gPageSize, EChkCreateBottomNegative);

 	test.Next(_L("Test RChunk::CreateDoubleEndedLocal - invalid top"));

 	TestPanicChunkCreate2(ECreateLocalDE, 0, -1, gPageSize, EChkCreateTopNegative);

 	test.Next(_L("Test RChunk::CreateDoubleEndedLocal - bottom > top"));

 	TestPanicChunkCreate2(ECreateLocalDE, gPageSize, 0, gPageSize, EChkCreateTopLessThanBottom);

 	test.Next(_L("Test RChunk::CreateDoubleEndedLocal - top > max size"));

 	TestPanicChunkCreate2(ECreateLocalDE, 0, gPageSize << 1, gPageSize, EChkCreateTopBiggerThanMax);

 	test.End();

 	}

 // 

 // TestGlobDEChunk

 //

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID			KBASE-T_CHUNKCREATE-xxxx

 //! @SYMTestType			UT

 //! @SYMPREQ				PREQ1954

 //! @SYMTestCaseDesc		Verify the global double ended chunk creation implementation

 //! @SYMTestActions			

 //! 1.	Create a global, double ended, chunk and specify the following paging options. 

 //!		Following this check the paging status of the chunk by calling IsPaged().

 //!		a.	Not specified

 //!		b.	Paged

 //!		c.	Unpaged

 //! 2.	Create a global, double ended, chunk and specify aMaxSize to be negative

 //! 3.	Create a global, double ended, chunk and specify aInitialBottom to be negative

 //! 4.	Create a global, double ended, chunk and specify aInitialTop to be negative.

 //! 5.	Create a global, double ended, chunk and specify aInitialBottom to be greater than aInitialTop.

 //! 6.	Create a global, double ended, chunk and specify aInitialBottom to be greater than aMaxSize.

 //! 7.	Create a global, double ended, chunk and specify aInitialTop to be greater than aMaxSize.

 //!

 //! @SYMTestExpectedResults 

 //! 1.	1.	The following results are expected:

 //!		a.	The chunk should take on the paging status of the process

 //!		b.	ETrue

 //!		c.	EFalse

 //! 2.	Panic USER99

 //! 3.	Panic USER120

 //! 4.	Panic USER121

 //! 5.	Panic USER122

 //! 6.	Panic USER123

 //! 7.	Panic USER123

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 void TestGlobDEChunk()

 	{

 	test.Start(_L("Test RChunk::CreateDoubleEndedGlobal - paging attributes"));

 		{

 		TChunkCreateInfo createInfo;

 		createInfo.SetDoubleEnded(0, gPageSize, gPageSize);

 		createInfo.SetGlobal(KGlobalChunkName);

 		VerifyChunkPaged(createInfo);

 		// Test default create method

 		TInt r = gChunk.CreateDoubleEndedLocal(0, gPageSize, gPageSize);

 		VerifyChunkPaged(gChunk, gProcessPaged, r);

 		}

 	test.Next(_L("Test RChunk::CreateDoubleEndedGlobal - invalid max size"));

 	TestPanicChunkCreate2(ECreateGlobalDE, 0, gPageSize, -1, EChkCreateMaxSizeNegative);

 	test.Next(_L("Test RChunk::CreateDoubleEndedGlobal - invalid bottom"));

 	TestPanicChunkCreate2(ECreateGlobalDE, -1, gPageSize, gPageSize, EChkCreateBottomNegative);

 	test.Next(_L("Test RChunk::CreateDoubleEndedGlobal - invalid top"));

 	TestPanicChunkCreate2(ECreateGlobalDE, 0, -1, gPageSize, EChkCreateTopNegative);

 	test.Next(_L("Test RChunk::CreateDoubleEndedGlobal - bottom > top"));

 	TestPanicChunkCreate2(ECreateGlobalDE, gPageSize, 0, gPageSize, EChkCreateTopLessThanBottom);

 	test.Next(_L("Test RChunk::CreateDoubleEndedGlobal - top > max size"));

 	TestPanicChunkCreate2(ECreateGlobalDE, 0, gPageSize << 1, gPageSize, EChkCreateTopBiggerThanMax);

 	test.End();

 	}

 // 

 // TestLocDiscChunk

 //

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID			KBASE-T_CHUNKCREATE-xxxx

 //! @SYMTestType			UT

 //! @SYMPREQ				PREQ1954

 //! @SYMTestCaseDesc		Verify the local disconnected chunk creation implementation

 //! @SYMTestActions			

 //! 1.	Create a local, disconnected chunk and specify the following paging options. 

 //!		Following this check the paging status of the chunk by calling IsPaged().

 //!		a.	Not specified

 //!		b.	Paged

 //!		c.	Unpaged

 //! 2.	Create a local, disconnected chunk and specify aMaxSize to be negative

 //! 3.	Create a local, disconnected chunk and specify aInitialBottom to be negative

 //! 4.	Create a local, disconnected chunk and specify aInitialTop to be negative.

 //! 5.	Create a local, disconnected chunk and specify aInitialBottom to be greater than aInitialTop.

 //! 6.	Create a local, disconnected chunk and specify aInitialBottom to be greater than aMaxSize.

 //! 7.	Create local, disconnected chunk and specify aInitialTop to be greater than aMaxSize.

 //!

 //! @SYMTestExpectedResults 

 //! 1.	1.	The following results are expected:

 //!		a.	The chunk should take on the paging status of the process

 //!		b.	ETrue

 //!		c.	EFalse

 //! 2.	Panic USER99

 //! 3.	Panic USER120

 //! 4.	Panic USER121

 //! 5.	Panic USER122

 //! 6.	Panic USER123

 //! 7.	Panic USER123

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 void TestLocDiscChunk()

 	{

 	test.Start(_L("Test RChunk::CreateDisconnectedLocal - paging attributes"));

 		{

 		TChunkCreateInfo createInfo;

 		createInfo.SetDisconnected(0, gPageSize, gPageSize);

 		VerifyChunkPaged(createInfo);

 		// Test default create method

 		TInt r = gChunk.CreateDoubleEndedLocal(0, gPageSize, gPageSize);

 		VerifyChunkPaged(gChunk, gProcessPaged, r);

 		}

 	test.Next(_L("Test RChunk::CreateDisconnectedLocal - invalid max size"));

 	TestPanicChunkCreate2(ECreateLocalDC, 0, gPageSize, -1, EChkCreateMaxSizeNegative);

 	test.Next(_L("Test RChunk::CreateDisconnectedLocal - invalid bottom"));

 	TestPanicChunkCreate2(ECreateLocalDC, -1, gPageSize, gPageSize, EChkCreateBottomNegative);

 	test.Next(_L("Test RChunk::CreateDisconnectedLocal - invalid top"));

 	TestPanicChunkCreate2(ECreateLocalDC, 0, -1, gPageSize, EChkCreateTopNegative);

 	test.Next(_L("Test RChunk::CreateDisconnectedLocal - bottom > top"));

 	TestPanicChunkCreate2(ECreateLocalDC, gPageSize, 0, gPageSize, EChkCreateTopLessThanBottom);

 	test.Next(_L("Test RChunk::CreateDisconnectedLocal - top > max size"));

 	TestPanicChunkCreate2(ECreateLocalDC, 0, gPageSize << 1, gPageSize, EChkCreateTopBiggerThanMax);

 	test.End();

 	}

 // 

 // TestGlobDiscChunk

 //

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID			KBASE-T_CHUNKCREATE-xxxx

 //! @SYMTestType			UT

 //! @SYMPREQ				PREQ1954

 //! @SYMTestCaseDesc		Verify the global disconnected chunk creation implementation

 //! @SYMTestActions			

 //! 1.	Create a global, disconnected chunk and specify the following paging options. 

 //!		Following this check the paging status of the chunk by calling IsPaged().

 //!		a.	Not specified

 //!		b.	Paged

 //!		c.	Unpaged

 //! 2.	Create a global, disconnected chunk and specify aMaxSize to be negative

 //! 3.	Create a global, disconnected chunk and specify aInitialBottom to be negative

 //! 4.	Create a global, disconnected chunk and specify aInitialTop to be negative.

 //! 5.	Create a global, disconnected chunk and specify aInitialBottom to be greater than aInitialTop.

 //! 6.	Create a global, disconnected chunk and specify aInitialBottom to be greater than aMaxSize.

 //! 7.	Create global, disconnected chunk and specify aInitialTop to be greater than aMaxSize.

 //!

 //! @SYMTestExpectedResults 

 //! 1.	1.	The following results are expected:

 //!		a.	The chunk should take on the paging status of the process

 //!		b.	ETrue

 //!		c.	EFalse

 //! 2.	Panic USER99

 //! 3.	Panic USER120

 //! 4.	Panic USER121

 //! 5.	Panic USER122

 //! 6.	Panic USER123

 //! 7.	Panic USER123

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 void TestGlobDiscChunk()

 	{

 	test.Start(_L("Test RChunk::CreateDisconnectedGlobal - paging attributes"));

 		{

 		TChunkCreateInfo createInfo;

 		createInfo.SetDisconnected(0, gPageSize, gPageSize);

 		createInfo.SetGlobal(KGlobalChunkName);

 		VerifyChunkPaged(createInfo);

 		// Test default create method

 		TInt r = gChunk.CreateDoubleEndedLocal(0, gPageSize, gPageSize);

 		VerifyChunkPaged(gChunk, gProcessPaged, r);

 		}

 	test.Next(_L("Test RChunk::CreateDisconnectedGlobal - invalid max size"));

 	TestPanicChunkCreate2(ECreateGlobalDC, 0, gPageSize, -1, EChkCreateMaxSizeNegative);

 	test.Next(_L("Test RChunk::CreateDisconnectedGlobal - invalid bottom"));

 	TestPanicChunkCreate2(ECreateGlobalDC, -1, gPageSize, gPageSize, EChkCreateBottomNegative);

 	test.Next(_L("Test RChunk::CreateDisconnectedGlobal - invalid top"));

 	TestPanicChunkCreate2(ECreateGlobalDC, 0, -1, gPageSize, EChkCreateTopNegative);

 	test.Next(_L("Test RChunk::CreateDisconnectedGlobal - bottom > top"));

 	TestPanicChunkCreate2(ECreateGlobalDC, gPageSize, 0, gPageSize, EChkCreateTopLessThanBottom);

 	test.Next(_L("Test RChunk::CreateDisconnectedGlobal - top > max size"));

 	TestPanicChunkCreate2(ECreateGlobalDC, 0, gPageSize << 1, gPageSize, EChkCreateTopBiggerThanMax);

 	test.End();

 	}

 TInt TestingTChunkCreate()

 	{

 	test.Start(_L("Test TChunkCreateInfo - Local Chunk"));

 	TestLocalChunk();

 	test.Next(_L("Test TChunkCreateInfo - Code Chunk"));

 	TestCodeChunk();

 	test.Next(_L("Test TChunkCreateInfo - Global Chunk"));

 	TestGlobalChunk();

 	test.Next(_L("Test TChunkCreateInfo - Local Double Ended Chunk"));

 	TestLocDEChunk();

 	test.Next(_L("Test TChunkCreateInfo - Global Double Ended Chunk"));

 	TestGlobDEChunk();

 	test.Next(_L("Test TChunkCreateInfo - Local Disconnected Chunk"));

 	TestLocDiscChunk();

 	test.Next(_L("Test TChunkCreateInfo - Global Disconnected Chunk"));

 	TestGlobDiscChunk();

 	test.End();

 	return 0;

 	}