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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Puts some test feature registry configuration files - some corrupt, others legal -

// in the C: private data cage of the setup executable. Sets up test RProperties.

// 

//

/**

 @file

 @internalComponent

 @test

*/

#include <e32cmn.h>

#include <e32base.h>

#include <f32file.h>

#include <e32property.h>

#include <featreg.h>

#include "featregcmn.h"

#include "maketestconfig.h"

// names of test configurations that can be set up by this exe, specified as

// command-line option:

_LIT(KFeatRegTestConfig_force_setup,				"force_setup");

_LIT(KFeatRegTestConfig_reset,						"reset");

_LIT(KFeatRegTestConfig_corrupt_missing,			"corrupt_missing");

_LIT(KFeatRegTestConfig_corrupt_noheader,			"corrupt_noheader");

_LIT(KFeatRegTestConfig_corrupt_incompleteheader,	"corrupt_incompleteheader");

_LIT(KFeatRegTestConfig_corrupt_invalidtypeprefix,	"corrupt_invalidtypeprefix");

_LIT(KFeatRegTestConfig_corrupt_badversionnumber,	"corrupt_badversionnumber");

_LIT(KFeatRegTestConfig_corrupt_toomuchdata,		"corrupt_toomuchdata");

_LIT(KFeatRegTestConfig_corrupt_toolittledata,		"corrupt_toolittledata");

_LIT(KFeatRegTestConfig_corrupt_entryoutoforder,	"corrupt_entryoutoforder");

_LIT(KFeatRegTestConfig_corrupt_entryrepeated,		"corrupt_entryrepeated");

_LIT(KFeatRegTestConfig_corrupt_badrange,			"corrupt_badrange");

_LIT(KFeatRegTestConfig_valid_nofeatures,			"valid_nofeatures");

_LIT(KFeatRegTestConfig_valid_small,				"valid_small");

_LIT(KFeatRegTestConfig_valid_large,				"valid_large");

_LIT(KFeatRegTestConfig_valid_perf,				    "valid_perf_");

TConfigFileName ConfigFileName;

static TInt DefineTestFlagProperty()

	{

	RProcess thisProcess;

	// sanity check that feature property category in common header equals SID of this process

	ASSERT(KFeaturePropCat == thisProcess.SecureId());

	TSecurityPolicy readPolicy(TSecurityPolicy::EAlwaysPass);

	TSecurityPolicy writePolicy(thisProcess.SecureId());

	TInt result = RProperty::Define(KFeatRegConfigTestKey, RProperty::EInt, readPolicy, writePolicy);

	if (result == KErrAlreadyExists)

		{

		result = KErrNone;

		}

	return result;

	}

static TInt WriteTestConfigFile(TUint32* aData, TInt aSize)

	{

	RFs fs;

	TInt result = fs.Connect();

	if (result == KErrNone)

		{

		result = fs.MkDirAll(ConfigFileName);

		if ((result == KErrNone) || (result == KErrAlreadyExists))

			{

			RFile cfgFile;

			result = cfgFile.Replace(fs, ConfigFileName, EFileWrite|EFileStream);

			if (result == KErrNone)

				{

				result = cfgFile.Write(TPtrC8(reinterpret_cast<const TUint8 *>(aData), aSize));

				cfgFile.Close();

				}

			}

		fs.Close();

		}

	if (result == KErrNone)

		{

		result = DefineTestFlagProperty();

		}

	return result;

	}

TInt E32Main()

	{

	__UHEAP_MARK;

	TFileName configName;

	User::CommandLine(configName);

	// construct config filename

	GetSystemDrivePath(ConfigFileName);

	// always delete feature property so featreg.dll re-loads it (note this

	// executable has same UID3 as featreg setup:

	TInt result = RProperty::Delete(KFeaturePropKey);

	if (result == KErrNotFound)

		{

		result = KErrNone;

		}

	if (result != KErrNone)

		{

		goto cleanupReturn;

		}

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

	if (configName.Find(KFeatRegTestConfig_force_setup) >= 0)

		{

		// force setup

		// nothing to do; just ensures feature property is deleted so setup is run

		}

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

	else if (configName.Find(KFeatRegTestConfig_reset) >= 0)

		{

		// reset

		// delete "test-flag" property so setup looks at true config info

		result = RProperty::Delete(KFeatRegConfigTestKey);

		if (result == KErrNotFound)

			{

			result = KErrNone;

			}

		}

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

	else if (configName.Find(KFeatRegTestConfig_corrupt_missing) >= 0)

		{

		// no header

		RFs fs;

		result = fs.Connect();

		if (result == KErrNone)

			{

			result = fs.Delete(ConfigFileName);

			if ((result == KErrNotFound) || (result == KErrPathNotFound))

				{

				result = KErrNone;

				}

			fs.Close();

			}

		if (result == KErrNone)

			{

			result = DefineTestFlagProperty();

			}

		}

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

	else if (configName.Find(KFeatRegTestConfig_corrupt_noheader) >= 0)

		{

		// no header

		result = WriteTestConfigFile(NULL, 0);

		}

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

	else if (configName.Find(KFeatRegTestConfig_corrupt_incompleteheader) >= 0)

		{

		// header is not complete

		TUint32 fileData1[] =

			{

			validTypePrefix,

			0,	// version number, must be zero

			0	// entry count

				// range count: missing

			};

		result = WriteTestConfigFile(fileData1, sizeof(fileData1));

		}

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

	else if (configName.Find(KFeatRegTestConfig_corrupt_invalidtypeprefix) >= 0)

		{

		// invalid type prefix

		TUint32 fileData1[] =

			{

			invalidTypePrefix,	 // should be validTypePrefix

			0,	// version number

			0,	// entry count

			0	// range count

			};

		result = WriteTestConfigFile(fileData1, sizeof(fileData1));

		}

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

	else if (configName.Find(KFeatRegTestConfig_corrupt_badversionnumber) >= 0)

		{

		// bad file version header

		TUint32 fileData1[] =

			{

			validTypePrefix,

			1,	// version number: not zero

			0,	// entry count

			0	// range count

			};

		result = WriteTestConfigFile(fileData1, sizeof(fileData1));

		}

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

	else if (configName.Find(KFeatRegTestConfig_corrupt_toomuchdata) >= 0)

		{

		// corrupt: config file contains more data than required by header

		TUint32 fileData2[] =

			{

			validTypePrefix,

			0,	// version number, must be zero

			0,	// entry count

			0,	// range count

			0,	// unexpected extra data

			};

		result = WriteTestConfigFile(fileData2, sizeof(fileData2));

		}

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

	else if (configName.Find(KFeatRegTestConfig_corrupt_toolittledata) >= 0)

		{

		// corrupt: config file contains less data than required by header

		TUint32 fileData3[] =

			{

			validTypePrefix,

			0,	// version number, must be zero

			2,	// entry count

			1	// range count

				// should be 2 entries (2 words each) and 1 default range (2 words each)

			};

		result = WriteTestConfigFile(fileData3, sizeof(fileData3));

		}

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

	else if (configName.Find(KFeatRegTestConfig_corrupt_entryoutoforder) >= 0)

		{

		// corrupt: feature entries not ordered from lowest to highest UID

		TUint32 fileData4[] =

			{

			validTypePrefix,

			0,	// version number, must be zero

			3,	// entry count

			0,	// range count

			2,	// Feature UID = 2

			1,	//   status low-bit set -> present

			5,	// Feature UID = 5

			1,	//   status low-bit set -> present

			3,	// Feature UID = 3: Feature UIDs not in strictly increasing order

			1	//   status low-bit set -> present

			};

		result = WriteTestConfigFile(fileData4, sizeof(fileData4));

		}

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

	else if (configName.Find(KFeatRegTestConfig_corrupt_entryrepeated) >= 0)

		{

		// corrupt: repeated feature UID

		TUint32 fileData5[] =

			{

			validTypePrefix,

			0,	// version number, must be zero

			3,	// entry count

			0,	// range count

			2,	// Feature UID = 2

			1,	//   status low-bit set -> present

			5,	// Feature UID = 5

			1,	//   status low-bit set -> present

			5,	// Feature UID = 5: Feature UID repeated

			1,	//   status low-bit set -> present

			};

		result = WriteTestConfigFile(fileData5, sizeof(fileData5));

		}

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

	else if (configName.Find(KFeatRegTestConfig_corrupt_badrange) >= 0)

		{

		// corrupt: default-supported range not listed in order lowUid-highUid

		TUint32 fileData6[] =

			{

			validTypePrefix,

			0,	// version number, must be zero

			1,	// entry count

			2,	// range count

			2,	// Feature UID = 2

			1,	//   status low-bit set -> present

			5,	// Range 1 low UID

			9,	//         high UID

			88,	// Range 2 low UID

			76	//         high UID: not >= lowUID

			};

		result = WriteTestConfigFile(fileData6, sizeof(fileData6));

		}

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

	else if (configName.Find(KFeatRegTestConfig_valid_nofeatures) >= 0)

		{

#ifndef SYMBIAN_FEATURE_MANAGER

		// valid: no features

				TUint32 fileData7[] =

					{

					validTypePrefix,

					0,	// version number, must be zero

					0,	// entry count

					0	// range count

					};

#else	

		// valid: no features

				TUint32 fileData7[] =

					{

					validTypePrefix,

					0,	// version number, must be zero

					0,	// entry count

					1,	// range count: we have to provide at least one range, otherwise the file will be corrupt from the FeatMgr perspective

					KFeatRegTest_DummyRangeId,

					KFeatRegTest_DummyRangeId

					};		

#endif	

		result = WriteTestConfigFile(fileData7, sizeof(fileData7));

		}

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

	else if (configName.Find(KFeatRegTestConfig_valid_small) >= 0)

		{

		// valid: few features, one default=supported range

		TUint32 fileData8[] =

			{

			validTypePrefix,

			0,	// version number, must be zero

			2,	// entry count

			1,	// range count

			KFeatRegTest1_02_SNFeatId,	// 1. feature UID

			KFeatRegTest1_02_SNFeatSt,	//    status word; low bit set = supported

			KFeatRegTest1_05_URFeatId,	// 2. feature UID

			KFeatRegTest1_05_URFeatSt,	//    status word; low-bit not set = not supported

			KFeatRegTest1_03_LoFeatId,	// low-feature-UID of default=supported range

			KFeatRegTest1_04_HiFeatId	// high-feature-UID of default=supported range

			};

		result = WriteTestConfigFile(fileData8, sizeof(fileData8));

		}

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

	else if (configName.Find(KFeatRegTestConfig_valid_large) >= 0)

		{

		// valid: many features, several default=supported ranges

		TUint32 fileData9[2 + 2*KFeatRegTest2_04_numTestFeatures + 2*KFeatRegTest2_07_rangeCount];

		TInt j = sizeof(TFeatureHeader) / sizeof(TUint32);

		TInt entryCount = 0;

		TUint32 id = KFeatRegTest2_01_FirstId;

		// feature entries

		for (TInt e = KFeatRegTest2_04_numTestFeatures; e > 0; e--)

			{

			TBool featureSupported = !(id & KFeatRegTest2_05_NotSupportedBit);

			TBool inDefaultSupportedRange = id & KFeatRegTest2_06_DefSupportedBit;

			// only need to list feature if support differs from default ranges

			if (featureSupported && (!inDefaultSupportedRange))

				{

				fileData9[j++] = id;

				fileData9[j++] = RFeatureRegistry::EStatusSupportBit;

				entryCount++;

				}

			else if ((!featureSupported) && inDefaultSupportedRange)

				{

				fileData9[j++] = id;

				fileData9[j++] = 0;	// specifically listed as not supported

				entryCount++;

				}

			id += KFeatRegTest2_03_IncrId;

			}

		// default=supported ranges

		TUint32 lowId = KFeatRegTest2_06_DefSupportedBit;

		for (TUint r = 0; r < KFeatRegTest2_07_rangeCount; r++)

			{

			fileData9[j++] = lowId;

			fileData9[j++] = lowId + KFeatRegTest2_06_DefSupportedBit - 1;

			lowId += 2*KFeatRegTest2_06_DefSupportedBit;

			}

		// header

		fileData9[0] = validTypePrefix,

		fileData9[1] = 0;	// version number, must be zero

		fileData9[2] = entryCount;

		fileData9[3] = KFeatRegTest2_07_rangeCount;

		result = WriteTestConfigFile(fileData9, j*sizeof(TUint32));

		}

	else if (configName.Find(KFeatRegTestConfig_valid_perf) >= 0)

		{

		// extract the number of features to put into the file from the

		// arguments supplied to the process from the script

	    TInt digitchar = 0;

	    TChar charItem(configName[digitchar]);

	    while (charItem.IsDigit() == EFalse)

           charItem = configName[++digitchar]; 

	    if (digitchar >= configName.Length())

	    	{

	    	result = KErrArgument;

	    	goto cleanupReturn;

	    	}

		TPtrC16 counter = configName.Mid(digitchar);

		TLex lex1(counter);

		TInt count = 0;

        lex1.Val(count);

		// valid: allocate space for maximum number of features we would expect

		TInt j = sizeof(TFeatureHeader) / sizeof(TUint32);

		TUint32 fileData9[4 + 2*8001]; // j must == 4

		TInt entryCount = 0;

		TUint32 id = KFeatRegTest2_01_FirstId;

		// create 'count' number of feature entries

		for (TInt e = count; e > 0; e--)

			{

			fileData9[j++] = id;

			fileData9[j++] = (e&0x01) ? RFeatureRegistry::EStatusSupportBit : 0;

			entryCount++;

			id += KFeatRegTest2_03_IncrId;

			}

#ifndef SYMBIAN_FEATURE_MANAGER

		// header

		fileData9[0] = validTypePrefix,

		fileData9[1] = 0;	// version number, must be zero

		fileData9[2] = entryCount;

		fileData9[3] = 0;

#else

		//we have to provide at least one range, otherwise the file will be corrupt from the FeatMgr perspective 

		fileData9[j++] = KFeatRegTest_DummyRangeId;

		fileData9[j++] = KFeatRegTest_DummyRangeId;

		// header

		fileData9[0] = validTypePrefix,

		fileData9[1] = 0;	// version number, must be zero

		fileData9[2] = entryCount;

		fileData9[3] = 1;		

#endif		

		result = WriteTestConfigFile(fileData9, j*sizeof(TUint32));		

		}

	else

		{

		result = KErrArgument;

		}

cleanupReturn:

	__UHEAP_MARKEND;

	return result;

	}