Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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;
}