Moving feature configuration out of the buildrom scope.
/*
* Copyright (c) 2001-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:
* AreaSet Unit Tests
*
*/
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "r_areaset.h"
#include "r_rom.h"
////////////////////////////////////////////////////////////////////////
LOCAL_C void Test(TBool aExpr, const char* aMsg)
{
if (! aExpr)
{
cerr << "Test Failed: " << aMsg << '\n';
exit(1);
}
}
LOCAL_C void CheckAreas(const AreaSet* aPAreaSet, ...)
{
va_list l;
va_start(l, aPAreaSet);
TInt areaCount;
for (areaCount = 0;; ++areaCount)
{
const char* name = va_arg(l, const char*);
if (name == 0)
break;
TLinAddr startAddr = va_arg(l, TLinAddr);
TUint size = va_arg(l, TUint);
const Area* pArea = aPAreaSet->FindByName(name);
Test(pArea != 0, "unknown name");
Test(pArea->DestBaseAddr() == startAddr, "incorrect area start address");
Test(pArea->MaxSize() == size, "incorrect area size");
}
Test(areaCount == aPAreaSet->Count(), "incorrect number of areas");
va_end(l);
}
////////////////////////////////////////////////////////////////////////
LOCAL_C void TestAddAreaSuccess()
{
cout << "TestAddAreaSuccess...\n";
AreaSet areaSet;
const char KName1[] = "toto";
const TLinAddr KStart1 = 0x666;
const TUint KSize1 = 0x42;
const char* overlappingArea;
AreaSet::TAddResult r = areaSet.AddArea(KName1, KStart1, KSize1, overlappingArea);
Test(r == AreaSet::EAdded, "adding area 1");
Test(overlappingArea == 0, "incorrect overlapping area 1");
CheckAreas(&areaSet, KName1, KStart1, KSize1, 0);
const char KName2[] = "foobar";
const TLinAddr KStart2 = 0x100000;
const TUint KSize2 = 0x100;
r = areaSet.AddArea(KName2, KStart2, KSize2, overlappingArea);
Test(r == AreaSet::EAdded, "adding area 2");
Test(overlappingArea == 0, "incorrect overlapping area 2");
CheckAreas(&areaSet, KName1, KStart1, KSize1, KName2, KStart2, KSize2, 0);
}
LOCAL_C void TestAddingTwoAreas(const char* aName1, TLinAddr aDestBaseAddr1, TUint aSize1,
const char* aName2, TLinAddr aDestBaseAddr2, TUint aSize2,
AreaSet::TAddResult aExpectedResult)
{
cout << "Testing overlap between " << aName1 << " and " << aName2 << "\n";
AreaSet areaSet;
const char* overlappingArea;
AreaSet::TAddResult r = areaSet.AddArea(aName1, aDestBaseAddr1, aSize1, overlappingArea);
Test(r == AreaSet::EAdded, "adding area 1");
Test(overlappingArea == 0, "incorrect overlapping area 1");
r = areaSet.AddArea(aName2, aDestBaseAddr2, aSize2, overlappingArea);
Test(r == aExpectedResult, "adding area 2");
Test(areaSet.Count() == ((aExpectedResult == AreaSet::EAdded) ? 2 : 1),
"incorrect area count");
if (aExpectedResult == AreaSet::EAdded)
{
Test(areaSet.Count() == 2, "incorrect area count (should be 2)");
Test(overlappingArea == 0, "incorrect overlapping area 2 (should be 0)");
}
else
{
Test(areaSet.Count() == 1, "incorrect area count (should be 1)");
if (aExpectedResult == AreaSet::EOverlap)
Test(strcmp(overlappingArea, aName1) == 0, "incorrect overlapping area 2 (bad name)");
else
Test(overlappingArea == 0, "incorrect overlapping area 2 (should be 0)");
}
}
LOCAL_C void TestAddAreaOverlap()
{
cout << "TestAddAreaOverlap...\n";
const char KNameInitial[] = "initial";
const TLinAddr KStartInitial = 0x1000;
const TUint KSizeInitial = 0x101;
// new area overlapping first byte of initial one
TestAddingTwoAreas(KNameInitial, KStartInitial, KSizeInitial,
"overlap 1", 0x0F00, 0x101, AreaSet::EOverlap);
// new area overlapping last byte of initial one
TestAddingTwoAreas(KNameInitial, KStartInitial, KSizeInitial,
"overlap 2", 0x01100, 0x101, AreaSet::EOverlap);
// new area embedded in the initial one
TestAddingTwoAreas(KNameInitial, KStartInitial, KSizeInitial,
"overlap 3", 0x01010, 0x10, AreaSet::EOverlap);
// existing area overlapping first byte of new one
TestAddingTwoAreas(KNameInitial, 0x0F00, 0x101, "overlap 10",
KStartInitial, KSizeInitial, AreaSet::EOverlap);
// existing area overlapping last byte of new one
TestAddingTwoAreas(KNameInitial, 0x01100, 0x101, "overlap 11",
KStartInitial, KSizeInitial, AreaSet::EOverlap);
// existing area embedded in the new one
TestAddingTwoAreas(KNameInitial, 0x01010, 0x10, "overlap 12",
KStartInitial, KSizeInitial, AreaSet::EOverlap);
// new area just before the initial one
TestAddingTwoAreas(KNameInitial, KStartInitial, KSizeInitial,
"overlap 4", 0x0F00, 0x100, AreaSet::EAdded);
// new area just after the initial one
TestAddingTwoAreas(KNameInitial, KStartInitial, KSizeInitial,
"overlap 5", 0x01101, 0x100, AreaSet::EAdded);
}
LOCAL_C void TestAddAreaDuplicateName()
{
cout << "TestAddAreaDuplicateName...\n";
TestAddingTwoAreas("foobar", 0x10, 0x10,
"foobar", 0x100, 0x10,
AreaSet::EDuplicateName);
}
LOCAL_C void TestAddAreaOverflow()
{
cout << "TestAddAreaOverflow...\n";
AreaSet areaSet;
const char KName1[] = "foobar";
const char* overlappingArea;
AreaSet::TAddResult r = areaSet.AddArea(KName1, 0xFFFFFFFF, 0x02, overlappingArea);
Test(r == AreaSet::EOverflow, "adding area 1");
Test(areaSet.Count() == 0, "incorrect count after trying to add area 1");
Test(areaSet.FindByName(KName1) == 0, "Unexpected name found after trying to add area 1");
Test(overlappingArea == 0, "incorrect overlapping area 1");
const char KName2[] = "barfoo";
r = areaSet.AddArea(KName2, 0xFFFFFFFF, 0xFFFFFFFF, overlappingArea);
Test(r == AreaSet::EOverflow, "adding area 2");
Test(areaSet.Count() == 0, "incorrect count after trying to add area 2");
Test(areaSet.FindByName(KName2) == 0, "Unexpected name found after trying to add area 2");
Test(overlappingArea == 0, "incorrect overlapping area 2");
}
LOCAL_C void TestAddArea()
{
TestAddAreaSuccess();
TestAddAreaOverlap();
TestAddAreaDuplicateName();
TestAddAreaOverflow();
}
LOCAL_C void TestSrcAddrManipulations()
{
cout << "TestSrcAddrManipulations...\n";
//
// Creating an AreaSet instance containing one area
//
AreaSet areaSet;
const char* overlappingArea;
const char KAreaName[] = "foobar";
const TUint KMaxSize = 10;
AreaSet::TAddResult r = areaSet.AddArea(KAreaName, 0x100, KMaxSize, overlappingArea);
Test(r == AreaSet::EAdded, "Failed to add area");
Area* area = areaSet.FindByName(KAreaName);
Test(area != 0, "Failed to find area");
Test(area->UsedSize() == 0, "used size before allocation");
const TUint KSrcBaseAddr = 0x100;
area->SetSrcBaseAddr(KSrcBaseAddr);
Test(area->SrcBaseAddr() == KSrcBaseAddr, "destination base address before allocation");
Test(area->SrcBaseAddr() == area->SrcLimitAddr(), "destination limit address before allocation");
//
// Allocating some space in the area
//
const TUint KAlloc1 = KMaxSize-1;
TUint overflow;
TBool allocated = area->ExtendSrcLimitAddr(KSrcBaseAddr+KAlloc1, overflow);
Test(allocated, "allocation 1 failed");
Test(area->UsedSize() == KAlloc1, "used size after allocation 1");
Test(area->SrcBaseAddr()+KAlloc1 == area->SrcLimitAddr(), "destination limit address after allocation 1");
//
// Allocating more than available
//
const TUint KAlloc2 = KMaxSize*2;
allocated = area->ExtendSrcLimitAddr(KSrcBaseAddr+KAlloc1+KAlloc2, overflow);
Test(! allocated, "allocation 2 should have failed");
Test(overflow == KAlloc2+KAlloc1 - KMaxSize, "overflow after allocation 2");
Test(area->UsedSize() == KAlloc1, "used size after allocation 2");
Test(area->SrcBaseAddr()+KAlloc1 == area->SrcLimitAddr(), "destination limit address after allocation 2");
//
// Allocating just enough to fill the area completely
//
const TUint KAlloc3 = KMaxSize-KAlloc1;
allocated = area->ExtendSrcLimitAddr(KSrcBaseAddr+KAlloc1+KAlloc3, overflow);
Test(allocated, "allocation 3 failed");
Test(area->UsedSize() == KAlloc1+KAlloc3, "used size after allocation 3");
Test(area->UsedSize() == area->MaxSize(), "used size and max size should be equal");
Test(area->SrcBaseAddr()+KAlloc1+KAlloc3 == area->SrcLimitAddr(), "destination limit address after allocation 3");
//
// Overflowing the area by one byte
//
const TUint KAlloc4 = 1;
allocated = area->ExtendSrcLimitAddr(KSrcBaseAddr+KAlloc1+KAlloc3+KAlloc4, overflow);
Test(! allocated, "allocation 4 should have failed");
Test(overflow == 1, "overflow after allocation 4");
Test(area->UsedSize() == KAlloc1+KAlloc3, "used size after allocation 4");
Test(area->SrcBaseAddr()+KAlloc1+KAlloc3 == area->SrcLimitAddr(), "destination limit address after allocation 4");
}
LOCAL_C void TestFileIterator()
{
cout << "TestFileIterator...\n";
//
// Creating an area set containing one area
//
AreaSet areaSet;
const char* overlappingArea;
const char KAreaName[] = "foobar";
const TUint KMaxSize = 10;
AreaSet::TAddResult r = areaSet.AddArea(KAreaName, 0x100, KMaxSize, overlappingArea);
Test(r == AreaSet::EAdded, "Failed to add area");
Area* area = areaSet.FindByName(KAreaName);
Test(area != 0, "Failed to find area");
FilesInAreaIterator it1(*area);
Test(it1.IsDone(), "it1.IsDone()");
//
// Adding one file to that area
//
TRomBuilderEntry* pfile1 = new TRomBuilderEntry("file1", "file1");
area->AddFile(pfile1);
FilesInAreaIterator it2(*area);
Test(! it2.IsDone(), "! it2.IsDone() 1");
Test(it2.Current() == pfile1, "it2.Current() == pfile1");
it2.GoToNext();
Test(it2.IsDone(), "it2.IsDone()");
//
// Adding a second file to that area
//
TRomBuilderEntry* pFile2 = new TRomBuilderEntry("file2", "file2");
area->AddFile(pFile2);
FilesInAreaIterator it3(*area);
Test(! it3.IsDone(), "! it3.IsDone() 1");
Test(it3.Current() == pfile1, "it3.Current() == pfile1");
it3.GoToNext();
Test(! it3.IsDone(), "it3.IsDone() 2");
Test(it3.Current() == pFile2, "it3.Current() == pFile2");
it3.GoToNext();
Test(it3.IsDone(), "it3.IsDone()");
}
LOCAL_C void TestNonDefaultAreaIterator()
{
cout << "TestNonDefaultAreaIterator...\n";
//
// Creating an area set
//
AreaSet areaSet;
NonDefaultAreasIterator it1(areaSet);
Test(it1.IsDone(), "it1.IsDone()");
//
// Adding a first non default area
//
const char* overlappingArea;
const char KAreaName1[] = "area 1";
AreaSet::TAddResult r = areaSet.AddArea(KAreaName1, 0x100, 0x10, overlappingArea);
Test(r == AreaSet::EAdded, "Failed to add area 1");
Area* pArea1 = areaSet.FindByName(KAreaName1);
Test(pArea1 != 0, "Failed to find area 1");
NonDefaultAreasIterator it2(areaSet);
Test(! it2.IsDone(), "! it2.IsDone()");
Test(&it2.Current() == pArea1, "&it2.Current() == pArea1");
it2.GoToNext();
Test(it2.IsDone(), "it2.IsDone()");
//
// Adding a default area
//
r = areaSet.AddArea(AreaSet::KDefaultAreaName, 0x50000000, 0x00200000, overlappingArea);
Test(r == AreaSet::EAdded, "failed to add default area");
NonDefaultAreasIterator it3(areaSet);
Test(! it3.IsDone(), "! it3.IsDone()");
Test(&it3.Current() == pArea1, "&it3.Current() == pArea1");
it3.GoToNext();
Test(it3.IsDone(), "it3.IsDone()");
//
// Adding a second non default area
//
const char KAreaName2[] = "area 2";
r = areaSet.AddArea(KAreaName2, 0x1000, 0x10, overlappingArea);
Test(r == AreaSet::EAdded, "Failed to add area 2");
Area* pArea2 = areaSet.FindByName(KAreaName2);
Test(pArea2 != 0, "Failed to find area 2");
NonDefaultAreasIterator it4(areaSet);
Test(! it4.IsDone(), "! it4.IsDone()");
Test(&it4.Current() == pArea2, "&it4.Current() == pArea2");
it4.GoToNext();
Test(! it4.IsDone(), "it4.IsDone()");
Test(&it4.Current() == pArea1, "&it4.Current() == pArea1");
it4.GoToNext();
Test(it4.IsDone(), "it4.IsDone()");
}
////////////////////////////////////////////////////////////////////////
GLDEF_C int main()
{
TestAddArea();
TestSrcAddrManipulations();
TestFileIterator();
TestNonDefaultAreaIterator();
cout << "\nTests OK\n";
return 0;
}