// 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;
}