diff -r 000000000000 -r 2c201484c85f securityanddataprivacytools/securitytools/certapp/test/tcertapp/tcertapp.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/securityanddataprivacytools/securitytools/certapp/test/tcertapp/tcertapp.cpp	Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,1692 @@
+/*
+* 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: 
+*
+*/
+
+
+#include <iostream>
+#include "certapp-api.h"
+#include "badconfigwriter.h"
+#include "tcertapp_good.h"
+#include "tcertapp_bad.h"
+#include "goodconfigwriter.h"
+#include <string>
+#include <sstream>
+#include <stdlib.h>
+#include <stdio.h>
+#include "logger.h"
+#include "utils.h"
+
+using namespace std;
+
+//Funtions to generate Good/Valid config files for tcertapp
+void GoodFileCaCertTests(const stringstream &aFilename, int aArray_value);
+void GoodFileCertClientsTests(const stringstream &aFilename);
+void GoodSwiCertTests(const stringstream &aFilename, int aArray_value);
+
+//Functions to generate Good/Valid script files for emulator tests
+void GenerateGoodCaCertsTestScripts(const stringstream &aFilename);
+void GenerateGoodCertClientTestScripts(const stringstream &aFilename);
+void GenerateGoodSwiCertTestScripts(const stringstream &aFilename);
+
+//Funtions to generate Bad/illegal config files for tcertapp
+void BadFileCaCertTests(const stringstream &aFilename, int aArray_value);
+void BadFileCertClientsTests(const stringstream &aFilename, int aIndex);
+void BadSwiCertTests(const stringstream &aFilename, int aArray_value);
+
+//Function call for RunCertApp api
+void RunCertAppTool(int argc, char **argv, stringstream &aStringval);
+void RunCertAppToolForStoreDump(int aArgc, char **aArgv, stringstream &aStringval); 
+void RunCertAppToolForBadParams(int aArgc, char **aArgv, stringstream &aStringval); 
+
+void TestsWithEmptyConfigFile();
+void CreateFileToAugmentStore();
+void TestsWithEncodedFileFormats();
+void TestToDecodeAndEncodeStore();
+void TestToReviewingAggregateStore();
+void TestBadConfigFiles(const stringstream &aFilename, bool aBool);
+void CertClientBadParamsFuncCall(stringstream &aFileName);
+void decodeEncodeCertAppCall(const char *aArray[]);
+int CompareFiles(stringstream &aFileName1, stringstream &aFileName2);
+int Compare(istream &aIstream1, istream &aIstream2);
+void TestWithUnicodFileName();
+
+ofstream file; //global file handle to write to output file
+const char *progress = "progress.txt";  // logs the progress report
+const char *errors = "error.txt";       // logs the error report
+
+//some constants used
+const int KFileArrayIndex = 8;
+const int KSwicertIndex = 10;
+const int KSwiBadcertIndex = 11;
+const int KFileBadcertIndex = 9;
+const int KAppUidIndex = 4; 
+const int KIndex = 4;
+
+// to get the count of passed and failed test cases
+static int failCount = 0, passCount = 0;
+
+//pointers required for creation of good filecerts config files
+const char **filecert_array[KFileArrayIndex]=
+{
+	goodCert_array,
+	goodDeletables,
+	goodFormats,
+	goodCertOwnerTypes,
+	goodSubjectKeyIds,
+	goodIssuerKeyIds,
+	goodApplications,
+	goodTrusteds
+};
+
+//pointers required for creation of bad filecerts config files
+const char **badfilecert_array[KFileBadcertIndex]=
+{
+	badLabels,
+	badDeletables,
+	badFormats,
+	badCertOwnerTypes,
+	badSubjectKeyIds,
+	badIssuerKeyIds,
+	badApplications,
+	badTrusteds,
+	badDatafilePath
+};
+
+
+//pointers required for creation of good swicerts config files
+const char **swicert_array[KSwicertIndex]=
+{
+	goodLabels,
+	goodFormats,
+	goodCertOwnerTypes,
+	goodSubjectKeyIds,
+	goodIssuerKeyIds,
+	goodAppNames,
+	goodTrusteds,
+	goodCapabilitySets,
+	goodMandatory,
+	goodSystemUpgrade
+};
+
+//pointers required for creation of bad swicerts config files
+const char **badswicert_array[KSwiBadcertIndex]=
+{
+	badLabels,
+	badFormats,
+	badCertOwnerTypes,
+	badSubjectKeyIds,
+	badIssuerKeyIds,
+	badApplications,
+	badTrusteds,
+	badDatafilePath,
+	badCapabilitySets,
+	badMandatory,
+	badSystemUpgrade
+};
+
+
+//encoded file names for input to the tool
+const char *fileEncodeType[4]=
+{
+"--hfilecertstore=utf8.txt",
+"--hfilecertstore=utf8_without_bom.txt",
+"--hfilecertstore=ucs2-bigendian.txt",
+"--hfilecertstore=ucs2-littleendian.txt"
+};
+
+
+//RunCertApp call to create store from text input
+void RunCertAppTool( int argc, char **argv, stringstream &stringval)
+{
+	for(int i =0; i<argc; i++)
+		{
+		cout << "Arguments Being passed to the RunCertApp tool is " << argv[i] << endl;
+		}
+	int ret = RunCertApp(progress, errors, argc, argv); 
+	cout << "Return Value from CertApp Tool is " << ret << endl;
+	if(ret!= 0)
+		{
+		failCount++;
+		file<< "Error in creating store for " << stringval.str() << " and result is " << ret << " Fail" << endl ;
+		}
+	else
+		{
+		passCount++;
+		file << "No Error in creating store for " << stringval.str() << " and result is " << ret << " Pass" <<endl ;
+		}
+}
+
+//RunCertApp call to dump the store to human readable format
+void RunCertAppToolForStoreDump(int argc, char **argv, stringstream &stringval)
+{
+	int ret = RunCertApp(progress, errors, argc, argv); 
+	cout << "Return Value from CertApp Tool is " << ret << endl;
+	if(ret!= 0)
+		{
+		failCount++;
+		file<< "Error in Dumping the store file for " << stringval.str() << " and result is " << ret << " Fail" << endl ;
+		}
+	else
+		{
+		passCount++;
+		file << "No Error in Dumping store for " << stringval.str() << " and result is " << ret << " Pass" <<endl ;
+		}
+}
+
+//RunCertApp call to create store for bad params
+void RunCertAppToolForBadParams(int argc, char **argv, stringstream &stringval)
+{
+	int ret = RunCertApp(progress, errors, argc, argv); 
+	if(ret!= 0)
+		{
+		passCount++;
+		cout << "We have passsed bad paramerters! Expected Return value is -1 And the RunCertApp has returned " << ret << " as Expected"<< endl;
+		file<< "Bad Params! So Cannot create the store for " << stringval.str() << " and result is " << ret << " Pass" << endl ;
+		}
+	else
+		{
+		failCount++;
+		file << "We are using bad parameters! So the tools should fail to create store! " << stringval.str() << " and result is " << ret << " Fail" <<endl ;
+		cout << "We have passsed bad paramerters! The Tool has failed- It should return -1, But returned" << ret << endl;
+		}
+}
+
+
+/**
+main entry to the program
+*/
+int main(int /*argc*/, char ** /*argv*/)
+{
+	dbg.SetStream(&std::cout);
+	prog.SetStream(&std::cout);
+	std::cout << std::dec;
+
+	int num_tests = 0; 
+	int argCount3 = 3;
+	int argCount4 = 4;
+	// File to log the result of all tests
+	if(file)
+		{
+		file.open("tCertapp_Output.txt", ios_base::trunc | ios_base::out);
+		}
+
+	//create a file to augment the content to existing store
+	CreateFileToAugmentStore();
+
+	//create certclient config files 
+	//Format used for the files name is SDP-Security_Tools-CertApp-XXX-000X  to match with the TMS test case id
+	stringstream certclientfileName;
+	certclientfileName << "SDP-Security_Tools-CertApp-CCDAT_000"<<num_tests<<".txt";
+	GoodFileCertClientsTests(certclientfileName);
+	
+	//create command line argument for creation of certclientx.dat through certapp tool
+	stringstream strArg1, strArg2, augFileName;
+	strArg1 <<"--hcertclients=" << certclientfileName.str();
+	cout << "test" << strArg1.str().c_str() <<endl;
+
+	strArg2<< "--bcertclients=SDP-Security_Tools-CertApp-CCDAT_000" <<num_tests <<".dat";
+	cout <<"string value is " << strArg2.str().c_str() << endl;		
+	
+	string argument1, argument2;
+	const char *argv_certclient[4];
+	
+	argument1 = strArg1.str().c_str();
+	argv_certclient[0] = argument1.c_str();
+			
+	argv_certclient[1] = "--out";
+	argument2 = strArg2.str().c_str();
+	argv_certclient[2] = argument2.c_str();
+
+	char **argv, **argv1;
+	char *argument_ptr[3]; //[Format:: certapp --hcertclients=t_certclients_0.txt --out --bcertclients=certclients5.dat]
+
+	for(int n1 = 0; n1<argCount3; n1++)
+		{
+		argument_ptr[n1] = const_cast<char*>(argv_certclient[n1]);
+		argv = argument_ptr;
+		}
+	
+	RunCertAppTool(argCount3, argv, certclientfileName); // creating dat file
+	
+	//Augment the Store with Extra entries
+	augFileName<<"SDP-Security_Tools-CertApp-CCAUG_0000.dat";
+	argv_certclient[0] = "--hcertclients=tCertClient_Augment.txt";
+	argv_certclient[1] =  argv_certclient[2];  
+	argv_certclient[2] = "--out";
+	argv_certclient[3] = "--bcertclients=SDP-Security_Tools-CertApp-CCAUG_0000.dat";
+	for(int x = 0; x<argCount4; x++)
+			{
+			argument_ptr[x] = const_cast<char*>(argv_certclient[x]);
+			argv1 = argument_ptr;   
+			}
+	RunCertAppTool(argCount4, argv1, augFileName);
+
+	//Dump the dat file to human readable text format
+	argv_certclient[0] = argv_certclient[3];
+	argv_certclient[1] = "--out";
+	argv_certclient[2] = "--hcertclients=SDP-Security_Tools-CertApp-CCDUMP_0000.txt";
+			
+	for(int k = 0; k<argCount3; k++)
+		{
+		argument_ptr[k] = const_cast<char*>(argv_certclient[k]);
+		argv1 = argument_ptr;
+		}
+	RunCertAppToolForStoreDump(argCount3, argv1, certclientfileName); 
+	//End of t_certclients
+	
+	//Creates good config files to augment store and dump store to text format for file certstore - cacerts.dat
+	//Test for all positive cases
+	for(num_tests = 0; num_tests<=KFileArrayIndex; num_tests++)
+		{
+		stringstream caCertFileName;
+		caCertFileName << "SDP-Security_Tools-CertApp-FILEDAT_000"<<num_tests<<".txt";
+		GoodFileCaCertTests(caCertFileName,num_tests);
+
+		// CREATE CACERTS STORE FROM HUMAN READABLE TEXT INPUT
+		//ex:certapp --hcertclients=t_certclients_0.txt --hfilecertstore=t_cacerts_0.txt --out --bfilecertstore=cacerts_x.dat
+		stringstream strArg1, strArg2, strArg3, strArg4, strArg5;
+		strArg1 <<"--hfilecertstore=SDP-Security_Tools-CertApp-FILEDAT_000" <<num_tests << ".txt" ; 
+		
+		strArg2<< "--bfilecertstore=SDP-Security_Tools-CertApp-FILEDAT_000"<<num_tests <<".dat";
+		cout <<"string value is " << strArg2.str().c_str() << endl;	
+		
+		strArg3<< "--hcertclients=SDP-Security_Tools-CertApp-CCDAT_0000.txt";
+		cout <<"string value is " << strArg3.str().c_str() << endl;
+
+		string argument1, argument2, argument3, argument4, argument5;
+		const char *argv_certclient[4];
+		
+		argument1 = strArg1.str().c_str();
+		argument3 = strArg3.str().c_str();
+
+		argv_certclient[0] = argument3.c_str(); // --hcertclients=t_certclients_0.txt
+		argv_certclient[1] = argument1.c_str(); // --hfilecertstore=t_cacerts_x.txt
+		argv_certclient[2] = "--out";			//--out
+		argument2 = strArg2.str().c_str();
+		argv_certclient[3] = argument2.c_str(); //--bfilecertstore=cacerts_x.dat
+
+		char *argument_ptr[4]; 
+		char **argv, **argv1, **argv2 ;
+		for(int n = 0; n<argCount4; n++)
+			{
+			argument_ptr[n] = const_cast<char*>(argv_certclient[n]);
+			argv = argument_ptr;  
+			}
+		RunCertAppTool(argCount4, argv, caCertFileName); 
+
+		//AUGMENT THE CACERT STORE WITH EXTRA INFORMATION
+		//ex:certapp  --hfilecertstore=tAugment_cacerts_x.txt  --bfilecertstore=cacerts.dat --out --bfilecertstore=new_extra_filecertstore.dat
+		stringstream augFileName, textDumpFileName;
+		augFileName<<"SDP-Security_Tools-CertApp-FILEAUG_000" <<num_tests << ".dat";
+		strArg4<<"--bfilecertstore=SDP-Security_Tools-CertApp-FILEAUG_000" << num_tests << ".dat";
+		argument4 = strArg4.str();
+		argv_certclient[0] =  "--hfilecertstore=tfile_Augment.txt";  //--hfilecertstore=tAugment_cacerts_x.txt
+		argv_certclient[1] =  argv_certclient[3]; //--bfilecertstore=cacerts_x.dat
+		argv_certclient[2] = "--out";			  //--out
+		argv_certclient[3] = argument4.c_str();  //--bfilecertstore=aug_cacerts_x.dat
+		
+		for(int x = 0; x<argCount4; x++)
+			{
+			argument_ptr[x] = const_cast<char*>(argv_certclient[x]);
+			argv1 = argument_ptr;   
+			}
+		RunCertAppTool(argCount4, argv1, augFileName);
+
+		//DUMP THE STORE TO HUMAN READABLE FORMAT
+		//ex:certapp --bfilecertstore=test.dat --out --hfilecertstore=t_cacerts.txt 
+		textDumpFileName <<"SDP-Security_Tools-CertApp-FILEDUMP_000"<< num_tests << ".txt";
+		argv_certclient[0] =  argv_certclient[3];  //--bfilecertstore=aug_cacerts_x.dat
+		argv_certclient[1] = "--out";
+		strArg5<< "--hfilecertstore=SDP-Security_Tools-CertApp-FILEDUMP_000" <<num_tests << ".txt";
+		argument5 = strArg5.str().c_str();
+		argv_certclient[2] = argument5.c_str();
+						
+		for(int k = 0; k<argCount3; k++)
+			{
+			argument_ptr[k] = const_cast<char*>(argv_certclient[k]);
+			argv2 = argument_ptr;
+			}
+		//Dumps the augmented store
+		RunCertAppToolForStoreDump(argCount3, argv2, textDumpFileName); 
+		}//End of cacerts
+
+
+	//create config files with legal values for swi certstore 
+	for(num_tests = 0; num_tests<KSwicertIndex; num_tests++)
+		{
+		stringstream swiCertStoreFileName;
+		swiCertStoreFileName << "SDP-Security_Tools-CertApp-SWIDAT_000"<<num_tests<<".txt";
+		GoodSwiCertTests(swiCertStoreFileName,num_tests);
+
+		//CREATE THE SWICERTSTORE  FROM THE HUMAN READABLE TEXT INPUT
+		//Ex: certapp --hcertclients=t_certclients_0.txt --hswicertstore=t_swicertstore_0.txt --out --bswicertstore=swicertstore_x.dat
+		stringstream strArg1, strArg2, strArg3, strArg4, strArg5;
+		strArg1 <<"--hswicertstore=SDP-Security_Tools-CertApp-SWIDAT_000" <<num_tests << ".txt" ; //--hswicertstore=t_cacerts_x.txt
+		
+		strArg2<< "--bswicertstore=SDP-Security_Tools-CertApp-SWIDAT_000" <<num_tests <<".dat"; //--bswicertstore=swicertstore.dat
+		cout <<"string value is " << strArg2.str().c_str() << endl;	
+		
+		strArg3<< "--hcertclients=SDP-Security_Tools-CertApp-CCDAT_0000.txt";
+		cout <<"string value is " << strArg3.str().c_str() << endl;
+
+		string argument1, argument2, argument3, argument4, argument5;
+		const char *argv_certclient[4];
+		
+		argument1 = strArg1.str().c_str();
+		argument3 = strArg3.str().c_str();
+
+		argv_certclient[0] = argument3.c_str(); //--hcertclients=t_certclients_0.txt
+		argv_certclient[1] = argument1.c_str(); //--hswicertstore=t_swicertstore_
+		argv_certclient[2] = "--out";
+		argument2 = strArg2.str().c_str();
+		argv_certclient[3] = argument2.c_str();  //--bswicertstore=swicertstore_x.dat
+
+	    char *argument_ptr[4]; 
+	
+		for(int j=0; j<argCount4; j++)
+			{
+			cout << "Value in argv_certclient " << j << "is " <<argv_certclient[j] <<endl;
+			}
+
+		char **argv;
+		for(int n = 0; n<argCount4; n++)
+			{
+			argument_ptr[n] = const_cast<char*>(argv_certclient[n]);
+			argv = argument_ptr;
+			}
+		RunCertAppTool(argCount4, argv,swiCertStoreFileName); 
+
+		//AUGMENT THE CACERT STORE WITH EXTRA INFORMATION
+		//certapp  --hswicertstore=tAugment_swicertstore_x.txt  --bswicertstore=swicertstore_x.dat --out --bswicertstore=aug_swicertstore_x.dat
+		stringstream augFileName, textDumpFileName;
+		augFileName << "SDP-Security_Tools-CertApp-SWIAUG_000" << num_tests <<".dat";
+		strArg4<<"--bswicertstore=SDP-Security_Tools-CertApp-SWIAUG_000" << num_tests << ".dat";
+		argument4 = strArg4.str();
+		argv_certclient[0] =  "--hswicertstore=tswi_Augment.txt";  //--hswicertstore=tAugment_swicertstore_x.txt
+		argv_certclient[1] =  argv_certclient[3]; //--bswicertstore=swicertstore_x.dat
+		argv_certclient[2] = "--out";
+		argv_certclient[3] = argument4.c_str();  //--bswicertstore=aug_swicertstore_x.dat
+		char **argv1;
+		for(int x = 0; x<argCount4; x++)
+			{
+			argument_ptr[x] = const_cast<char*>(argv_certclient[x]);
+			argv1 = argument_ptr;   
+			}
+		RunCertAppTool(argCount4, argv1, augFileName);
+
+		//DUMP THE SWI CERTSTORE TO HUMAN READABLE FORMAT
+		textDumpFileName << "SDP-Security_Tools-CertApp-SWIDUMP_000" <<num_tests << ".txt";
+		argv_certclient[0] =  argv_certclient[3];  
+		argv_certclient[1] = "--out";
+		strArg5<< "--hswicertstore=SDP-Security_Tools-CertApp-SWIDUMP_000" <<num_tests << ".txt";
+		argument5= strArg5.str().c_str();
+		argv_certclient[2] = argument5.c_str();
+			
+		char ** argv2;
+		for(int k = 0; k<argCount3; k++)
+			{
+			argument_ptr[k] = const_cast<char*>(argv_certclient[k]);
+			argv2 = argument_ptr;
+			}
+
+		RunCertAppToolForStoreDump(argCount3, argv2, textDumpFileName); 
+		}
+	
+	//Test with unicode filename
+	TestWithUnicodFileName();
+
+	//create empty config file
+	TestsWithEmptyConfigFile();
+
+	//Test case to test for different file formats
+	TestsWithEncodedFileFormats();
+
+	//Test case for REQ10313 to check decode/encode of stores
+	TestToDecodeAndEncodeStore();
+
+	//Test case for REQ10314 - reviewing aggregate certificate database
+	TestToReviewingAggregateStore();
+
+	//Test cases for BAD Params
+	//create certclient config files 
+	for(num_tests =0; num_tests<3; num_tests++) 
+		{
+		stringstream badCertClientsFileName;
+		badCertClientsFileName << "SDP-Security_Tools-CertApp-CCBadParams-000"<<num_tests;
+		BadFileCertClientsTests(badCertClientsFileName,num_tests);
+		} //End of bad params for cerclients
+
+	//create bad config files for file certstore - cacerts.dat
+	for(num_tests = 0; num_tests<KFileArrayIndex+1; num_tests++)
+		{
+		stringstream badCaCertsFileName;
+		badCaCertsFileName << "SDP-Security_Tools-CertApp-FileBadParams-000"<<num_tests; 
+		BadFileCaCertTests(badCaCertsFileName,num_tests);
+		}
+	
+	//create config files with invalid values swi certstore 
+	for(num_tests = 0; num_tests<KSwiBadcertIndex; num_tests++)
+		{
+		stringstream badSwiCertsFileName;
+		badSwiCertsFileName << "SDP-Security_Tools-CertApp-SwiBadParams-000"<<num_tests;
+		BadSwiCertTests(badSwiCertsFileName,num_tests);
+		}
+
+	//Code to create Script files for the file/sw/certclients to run validation tests on emulator
+	//create script file for the symbian test harness-  for cacerts.dat
+	for(num_tests = 0; num_tests<1; num_tests++)
+		{
+		stringstream emu_CacertsFileName;
+		emu_CacertsFileName << "SDP-Security_Tools-CertApp-FILEDAT-EMU0"<<num_tests<<".txt";
+		GenerateGoodCaCertsTestScripts(emu_CacertsFileName);
+		}
+
+	//create script file for certclients.dat
+	for(num_tests = 0; num_tests<1; num_tests++)
+		{
+		stringstream emu_CertClientsFileName;
+		emu_CertClientsFileName << "SDP-Security_Tools-CertApp-CCDAT-EMU0"<<num_tests<<".txt";
+		GenerateGoodCertClientTestScripts(emu_CertClientsFileName);
+		}
+
+	//create script file for the symbian test harness-  for swicerts.dat
+	for(num_tests = 0; num_tests<1; num_tests++)
+		{
+		stringstream emu_SwiCertsFileName;
+		emu_SwiCertsFileName << "SDP-Security_Tools-CertApp-SWIDAT-EMU0"<<num_tests<<".txt";
+		GenerateGoodSwiCertTestScripts(emu_SwiCertsFileName);
+		}
+
+	int testCaseCount = failCount+passCount;
+	cout  << "\nTestrun result is :: " << failCount <<" tests failed out of " << testCaseCount <<endl;
+	file << "\n\nTotal number of test cases run is -> " << testCaseCount << endl;
+	file << failCount << " tests failed out of " << testCaseCount <<endl;
+	file.close();
+	return 0;
+}
+
+
+
+/**
+Function to create input file for augmenting the existing store
+*/
+void CreateFileToAugmentStore()
+{
+	stringstream swifilename, cacertsfilename, certclientName;
+	swifilename <<"tswi_Augment.txt";
+	cacertsfilename<< "tfile_Augment.txt";
+	certclientName << "tCertClient_Augment.txt";
+
+	SwiCertStoreConfigWriter swiwriter(swifilename);
+	swiwriter.WriteExtraSwiEntry();
+	
+	FileCertStoreConfigWriter filewriter(cacertsfilename);
+	filewriter.WriteExtraFileEntry();
+
+	FileCertClientConfigWriter certclientwriter(certclientName);
+	certclientwriter.WriteExtraCertClientEntry();
+}
+
+
+/**
+Test case to check the certapp tool for unicode named config file
+Testing with only one unicode named config file for now
+*/
+void TestWithUnicodFileName()
+{
+	//unicode file name in utf8 format
+	const char *filename= "\xe4\xb8\x95\xe4\xb8\x8d\xe4\xb8\x8e\xe4\xb8\x90\xe4\xb8\x91\xe4\xb8\x96\xe4\xb8\x99\x2e\x74\x78\x74";
+	fstream fileHandle;
+
+	OpenUtf8FStreamForWrite(fileHandle,filename);
+
+	char * buffer;
+	long size;
+
+	ifstream infile ("SDP-Security_Tools-CertApp-CCDAT_0000.txt",ifstream::binary);
+	// get size of file
+	infile.seekg(0,ifstream::end);
+	size=infile.tellg();
+	infile.seekg(0);
+	// allocate memory for file content
+	buffer = new char [size];
+	// read content of infile
+	infile.read (buffer,size);
+	// write to outfile
+	fileHandle.write (buffer,size);
+  
+	// release dynamically-allocated memory
+	delete[] buffer;
+	fileHandle.close();
+	infile.close();
+
+	//create argument list for certapp
+	const char *argv_certclient[3];
+	stringstream str1;
+	str1 <<"--hcertclients=" << filename;
+	string string1;
+	string1 = str1.str();
+
+	argv_certclient[0] =  string1.c_str();
+	argv_certclient[1] = "--out";
+	argv_certclient[2] = "--bcertclients=SDP-Security_Tools-CertApp-UNI00.dat";
+	
+	char **argv;
+	char *argument_ptr[3];
+	int argCount=3;
+	for(int n = 0; n<argCount; n++)
+		{
+		argument_ptr[n] = const_cast<char*>(argv_certclient[n]);
+		argv = argument_ptr;
+		}
+
+	for(int i =0; i<argCount; i++)
+		{
+		cout << "Arguments Being passed to the RunCertApp tool is " << argv[i] << endl;
+		}
+
+	int ret = RunCertApp(progress, errors, argCount, argv); 
+	cout << "Return value from certapp is " << ret <<endl;
+	if(ret!= 0)
+		{
+		failCount++;
+		file<< "Error in creating store using the unicode file name config file " << filename << " and result is " << ret << " Fail" << endl ;
+		}
+	else
+		{
+		passCount++;
+		file << "No Error in creating store using the unicode file named config file " << filename << " and result is " << ret << " Pass" <<endl ;
+		}
+}
+
+/**
+Generate Certclient config files
+*/
+void GoodFileCertClientsTests(const stringstream &aFilename)
+{
+	FileCertClientConfigWriter filewriter(aFilename);
+	const char *certclientPtr1; 
+	const char *certclientPtr2;
+	for(int i = 0; i<KAppUidIndex ; i++)
+		{
+		certclientPtr1 = goodAppNames[i];
+		certclientPtr2 = gooduid_array[i];
+		filewriter.WriteCertClientUid(certclientPtr2);
+		filewriter.WriteCertClientName(certclientPtr1);
+		}
+}
+
+
+/**
+Generate good config files for cacerts
+*/
+void GoodFileCaCertTests(const stringstream &aFilename ,int aValue)
+{
+	FileCertStoreConfigWriter fileCertWriter(aFilename);
+	const char **cacertPtr; 
+	const char **label = filecert_array[0];
+	switch(aValue)
+	{
+	case 0:
+		{
+		// Tests for GoodLabels
+		for(label = filecert_array[aValue]; *label; ++label)
+			{
+		
+			fileCertWriter.WriteFileEntry(*label);
+			}
+		break;
+		}
+	case 1:
+		{
+		// Tests for GoodDeletables
+		for(cacertPtr = filecert_array[aValue]; *cacertPtr; ++cacertPtr)
+			{
+			fileCertWriter.WriteFileEntry(*label,*cacertPtr);
+			label++;
+			}
+		break;
+		}
+	case 2:
+		{
+		//Tests for GoodFormats
+		for(cacertPtr = filecert_array[aValue]; *cacertPtr; ++cacertPtr)
+			{
+			fileCertWriter.WriteFileEntry(*label,0,*cacertPtr);
+			label++;
+			}
+		break;
+		}
+	case 3:
+		{
+		//Tests for GoodCertOwnerTypes
+		for(cacertPtr = filecert_array[aValue]; *cacertPtr; ++cacertPtr)
+			{
+			fileCertWriter.WriteFileEntry(*label,0,0,*cacertPtr);
+			label++;
+			}
+		break;
+		}
+	case 4:
+		{
+		//Tests for GoodSubjectKeyIds
+		for(cacertPtr = filecert_array[aValue]; *cacertPtr; ++cacertPtr)
+			{
+			fileCertWriter.WriteFileEntry(*label,0,0,0,*cacertPtr);
+			label++;
+			}
+		break;
+		}
+	case 5:
+		{
+		//Tests for GoodIssuerKeyIds
+		for(cacertPtr = filecert_array[aValue]; *cacertPtr; ++cacertPtr)
+			{
+			fileCertWriter.WriteFileEntry(*label,0,0,0,0,*cacertPtr);
+			label++;
+			}
+		break;
+		}
+	case 6:
+		{
+		//Tests for GoodApplications
+		for(cacertPtr = filecert_array[aValue]; *cacertPtr; ++cacertPtr)
+			{
+			fileCertWriter.WriteFileEntry(*label,0,0,0,0,0,*cacertPtr);
+			label++;
+			}
+		break;
+		}
+	case 7:
+		{
+		//Tests for GoodTrusteds
+		for(cacertPtr = filecert_array[aValue]; *cacertPtr; ++cacertPtr)
+			{
+			fileCertWriter.WriteFileEntry(*label,0,0,0,0,0,0,*cacertPtr);
+			label++;
+			}
+		break;
+		}
+	
+	case 8:
+		{	
+		//Test for PEM support
+		const char* datafilename = "\"root5ca.pem\"";
+		fileCertWriter.WriteFileEntry(*label,0,0,0,0,0,0,0,datafilename);
+		}
+		break;
+	
+	default:
+		break;
+	}
+}
+
+/**
+Generate  config file for swicert
+*/
+void GoodSwiCertTests(const stringstream &aFilename, int aIndex)
+{
+	SwiCertStoreConfigWriter swiWriter(aFilename);
+	const char **swiPtr1, **swiPtr2; 
+	swiPtr2 = swicert_array[0]; // labels for all scripts
+	switch(aIndex)
+	{
+	case 0:
+		{
+		// Tests for GoodLabels
+		for(swiPtr2=swicert_array[aIndex] ; *swiPtr2; ++swiPtr2)
+			{
+			swiWriter.WriteSwiEntry(*swiPtr2);
+			}
+		break;
+		}
+	case 1:
+		{
+		//Tests for GoodFormats
+		for(swiPtr1 = swicert_array[aIndex]; *swiPtr1; ++swiPtr1)
+			{
+			swiWriter.WriteSwiEntry(*swiPtr2,*swiPtr1);
+			++swiPtr2;
+			}
+		break;
+		}
+	case 2:
+		{
+		//Tests for GoodCertOwnerTypes
+		for(swiPtr1 = swicert_array[aIndex]; *swiPtr1; ++swiPtr1)
+			{
+			swiWriter.WriteSwiEntry(*swiPtr2,0,*swiPtr1);
+			++swiPtr2;
+			}
+		break;
+		}
+	case 3:
+		{
+		//Tests for GoodSubjectKeyIds
+		for(swiPtr1 = swicert_array[aIndex]; *swiPtr1; ++swiPtr1)
+			{
+			swiWriter.WriteSwiEntry(*swiPtr2,0,0,*swiPtr1);
+			++swiPtr2;
+			}
+		break;
+		}
+	case 4:
+		{
+		//Tests for GoodIssuerKeyIds
+		for(swiPtr1 = swicert_array[aIndex]; *swiPtr1; ++swiPtr1)
+			{
+			swiWriter.WriteSwiEntry(*swiPtr2,0,0,0,*swiPtr1);
+			++swiPtr2;
+			}
+		break;
+		}
+	case 5:
+		{
+		//Tests for GoodAswiPtr1lications
+		for(swiPtr1 = swicert_array[aIndex]; *swiPtr1; ++swiPtr1)
+			{
+			swiWriter.WriteSwiEntry(*swiPtr2,0,0,0,0,*swiPtr1);
+			++swiPtr2;
+			}
+		break;
+		}
+	case 6:
+		{
+		//Tests for GoodTrusteds
+		for(swiPtr1 = swicert_array[aIndex]; *swiPtr1; ++swiPtr1)
+			{
+			swiWriter.WriteSwiEntry(*swiPtr2,0,0,0,0,0,*swiPtr1);
+			++swiPtr2;
+			}
+		break;
+		}
+	case 7:
+		{
+		//Tests for GoodCapabilities
+		swiPtr1 = swicert_array[aIndex]; 
+		swiWriter.WriteSwiEntry(*swiPtr2,0,0,0,0,0,0,*swiPtr1);
+		break;
+		}
+	case 8:
+		{
+		//Tests for sGoodMandatory
+		for(swiPtr1 = swicert_array[aIndex]; *swiPtr1; ++swiPtr1)
+			{
+			swiWriter.WriteSwiEntry(*swiPtr2,0,0,0,0,0,0,0,*swiPtr1);
+			++swiPtr2;
+			}
+		break;
+		}
+	case 9:
+		{
+		//Tests for sGoodSystemUpgrade
+		for(swiPtr1 = swicert_array[aIndex]; *swiPtr1; ++swiPtr1)
+			{
+			swiWriter.WriteSwiEntry(*swiPtr2,0,0,0,0,0,0,0,0,*swiPtr1);
+			++swiPtr2;
+			}
+		break;
+		}
+	default:
+		break;
+	}
+}
+
+/**
+Generate config  files with invalid values for the store
+*/
+void TestBadConfigFiles(const stringstream &aFilename, bool aBool)
+{
+	// create command line input for cacerts
+	//Ex:certapp --hcertclients=t_certclients_0.txt --hfilecertstore=t_cacerts_0.txt --out --bfilecertstore=cacerts_x.dat
+	stringstream strArg1, strArg2, strArg3;
+	stringstream configFileName;
+	configFileName <<aFilename.str() << ".txt";
+	cout << aFilename.str() <<endl;
+	if(aBool == 0) // file store
+		{
+		strArg1 <<"--hfilecertstore="<<aFilename.str() <<".txt";;//--hfilecertstore=t_cacerts_x.txt
+		
+		strArg2<< "--bfilecertstore=" << aFilename.str() <<".dat"; //--bfilecertstore=cacerts_x.dat
+		cout <<"string value is " << strArg2.str().c_str() << endl;	
+		}
+	else  //swi store
+		{
+		strArg1 <<"--hswicertstore="<<aFilename.str() <<".txt";;//--hswicertstore=t_cacerts_x.txt
+		
+		strArg2<< "--bswicertstore=" << aFilename.str() <<".dat"; //--bswicertstore=cacerts_x.dat
+		cout <<"string value is " << strArg2.str().c_str() << endl;	
+		}
+
+	strArg3<< "--hcertclients=SDP-Security_Tools-CertApp-CCDAT_0000.txt";
+	cout <<"string value is " << strArg3.str().c_str() << endl;
+
+	string argument1, argument2, argument3;
+	const char *argv_certclient[4];
+	
+	argument1 = strArg1.str().c_str();
+	argument3 = strArg3.str().c_str();
+
+	argv_certclient[0] = argument3.c_str(); // --hcertclients=t_certclients_0.txt
+	argv_certclient[1] = argument1.c_str(); // --hfilecertstore=t_cacerts_x.txt
+	argv_certclient[2] = "--out";			//--out
+	argument2 = strArg2.str().c_str();
+	argv_certclient[3] = argument2.c_str(); //--bfilecertstore=cacerts_x.dat
+
+	char *argument_ptr[4]; 
+	int argCount4 = 4;
+	char **argv;
+	for(int n = 0; n<argCount4; n++)
+		{
+		argument_ptr[n] = const_cast<char*>(argv_certclient[n]);
+		argv = argument_ptr;   
+		}
+	RunCertAppToolForBadParams(argCount4, argv, configFileName); 
+}
+
+/**
+Generate bad config files for cacerts
+*/
+void BadFileCaCertTests(const stringstream &aFilename ,int aValue)
+{
+	const char **caCertPtr; 
+	int count = 0;
+	switch(aValue)
+	{
+	case 0:
+		{
+		// Tests for BadLabels
+		for(caCertPtr = badfilecert_array[aValue]; *caCertPtr ; ++caCertPtr )
+			{
+			stringstream file1, file2;
+			file1 << aFilename.str() <<"_"<<count;
+			file2 << aFilename.str() <<"_"<<count <<".txt";
+			FileBadCertStoreConfigWriter badcertfileWriter(file2);
+			badcertfileWriter.WriteFileEntry(*caCertPtr);
+			TestBadConfigFiles(file1, 0);
+			count++;
+			}
+		break;
+		}
+	case 1:
+		{
+		// Tests for BadDeletables
+		for(caCertPtr = badfilecert_array[aValue]; *caCertPtr; ++caCertPtr)
+			{
+			stringstream file1, file2;
+			file1 << aFilename.str() <<"_"<<count;
+			file2 << aFilename.str() <<"_"<<count <<".txt";
+			FileBadCertStoreConfigWriter badcertfileWriter(file2);
+			badcertfileWriter.WriteFileEntry(0,*caCertPtr);
+			TestBadConfigFiles(file1,0);
+			count++;
+			}
+		break;
+		}
+	case 2:
+		{
+		//Tests for BadFormats
+		for(caCertPtr = badfilecert_array[aValue]; *caCertPtr; ++caCertPtr)
+			{
+			stringstream file1, file2;
+			file1 << aFilename.str() <<"_"<<count;
+			file2 << aFilename.str() <<"_"<<count <<".txt";
+			FileBadCertStoreConfigWriter badcertfileWriter(file2);
+			badcertfileWriter.WriteFileEntry(0,0,*caCertPtr);
+			TestBadConfigFiles(file1,0);
+			count++;
+			}
+		break;
+		}
+	case 3:
+		{
+		//Tests for BadCertOwnerTypes
+		for(caCertPtr = badfilecert_array[aValue]; *caCertPtr; ++caCertPtr)
+			{
+			stringstream file1, file2;
+			file1 << aFilename.str() <<"_"<<count;
+			file2 << aFilename.str() <<"_"<<count <<".txt";
+			FileBadCertStoreConfigWriter badcertfileWriter(file2);
+			badcertfileWriter.WriteFileEntry(0,0,0,*caCertPtr);
+			TestBadConfigFiles(file1,0);
+			count++;
+			}
+		break;
+		}
+	case 4:
+		{
+		//Tests for BadSubjectKeyIds
+		for(caCertPtr = badfilecert_array[aValue]; *caCertPtr; ++caCertPtr)
+			{
+			stringstream file1, file2;
+			file1 << aFilename.str() <<"_"<<count;
+			file2 << aFilename.str() <<"_"<<count <<".txt";
+			FileBadCertStoreConfigWriter badcertfileWriter(file2);
+			badcertfileWriter.WriteFileEntry(0,0,0,0,*caCertPtr);
+			TestBadConfigFiles(file1,0);
+			count++;
+			}
+		break;
+		}
+	case 5:
+		{
+		//Tests for BadIssuerKeyIds
+		for(caCertPtr = badfilecert_array[aValue]; *caCertPtr; ++caCertPtr)
+			{
+			stringstream file1, file2;
+			file1 << aFilename.str() <<"_"<<count;
+			file2 << aFilename.str() <<"_"<<count <<".txt";
+			FileBadCertStoreConfigWriter badcertfileWriter(file2);
+			badcertfileWriter.WriteFileEntry(0,0,0,0,0,*caCertPtr);
+			TestBadConfigFiles(file1,0);
+			count++;
+			}
+		break;
+		}
+	case 6:
+		{
+		//Tests for BadApplications
+		caCertPtr = badfilecert_array[aValue];
+		stringstream file1, file2;
+		file1 << aFilename.str() <<"_"<<count;
+		file2 << aFilename.str() <<"_"<<count <<".txt";
+		FileBadCertStoreConfigWriter badcertfileWriter(file2);
+		badcertfileWriter.WriteFileEntry(0,0,0,0,0,0,*caCertPtr);
+		TestBadConfigFiles(file1,0);
+		break;
+		}
+	case 7:
+		{
+		//Tests for BadTrusteds
+		for(caCertPtr = badfilecert_array[aValue]; *caCertPtr; ++caCertPtr)
+			{
+			stringstream file1, file2;
+			file1 << aFilename.str() <<"_"<<count;
+			file2 << aFilename.str() <<"_"<<count <<".txt";
+			FileBadCertStoreConfigWriter badcertfileWriter(file2);
+			badcertfileWriter.WriteFileEntry(0,0,0,0,0,0,0,*caCertPtr);
+			TestBadConfigFiles(file1,0);
+			count++;
+			}
+		break;
+		}
+	case 8:
+		{
+		//Tests for BadDataFileName
+		for(caCertPtr = badfilecert_array[aValue]; *caCertPtr; ++caCertPtr)
+			{
+			stringstream file1, file2;
+			file1 << aFilename.str() <<"_"<<count;
+			file2 << aFilename.str() <<"_"<<count <<".txt";
+			FileBadCertStoreConfigWriter badcertfileWriter(file2);
+			badcertfileWriter.WriteFileEntry(0,0,0,0,0,0,0,0,*caCertPtr);
+			TestBadConfigFiles(file1,0);
+			count++;
+			}
+		break;
+		}
+	default:
+		break;
+	}
+}
+
+
+/**
+Generate bad Certclient config files
+*/
+void BadFileCertClientsTests(const stringstream &aFilename, int aIndex)
+{
+	FileBadCertClientConfigWriter certfileWriter(aFilename);
+	const char *certfilePtr1, *certfilePtr2; 
+	
+	switch(aIndex)
+	{
+	case 0:
+		{
+		for(int i=0; i<KAppUidIndex; i++) // 4 badUids[] length
+			{
+			stringstream file1, file2;
+			file2 << aFilename.str() << "_" << i ;
+			file1 << aFilename.str() <<"_"<<i <<".txt";
+			FileBadCertClientConfigWriter certfileWriter(file1);
+			certfilePtr1 = goodcertclient_array[0]; // good app name and 
+			certfilePtr2 = badUids[i];
+			certfileWriter.WriteCertClientUid(certfilePtr2); // bad uid entry
+			certfileWriter.WriteCertClientName(certfilePtr1);
+			CertClientBadParamsFuncCall(file2);
+			}
+		break;
+		}
+
+	case 1:
+		{
+		for(int i = 0; i<4 ; i++) // length of badcertclient_array
+			{
+			stringstream file1, file2;
+			file2 << aFilename.str() << "_" << i ;
+			file1 << aFilename.str() <<"_"<<i <<".txt";
+			FileBadCertClientConfigWriter certfileWriter(file1);
+			certfilePtr1 = badcertclient_array[i];
+			certfilePtr2 = goodUids[0];
+			certfileWriter.WriteCertClientUid(certfilePtr2);
+			certfileWriter.WriteCertClientName(certfilePtr1);
+			CertClientBadParamsFuncCall(file2);
+			}
+		break;
+		}
+	
+	// multiple names mapping to single uid
+	case 2:
+		{
+		stringstream file1;
+		file1 << aFilename.str() <<".txt";
+		FileBadCertClientConfigWriter certfileWriter(file1);
+		for(int i= 0; i<KAppUidIndex; i++)
+			{
+			certfilePtr1 = goodAppNames[i]; //app names - SW Install,SW install Ocsp Signing etc.
+			certfilePtr2 = goodUids[0];
+			certfileWriter.WriteCertClientName(certfilePtr1);
+			certfileWriter.WriteCertClientUid(certfilePtr2);
+			}
+		CertClientBadParamsFuncCall(file1);
+		break;
+		}
+	
+	default:
+		break;
+	}
+}
+
+
+void CertClientBadParamsFuncCall(stringstream &aFileName)
+{
+	//Ex:certapp --hcertclients=t_certclients_0.txt --out --bcertclients=t_certclients_0.dat 
+	stringstream strArg1, strArg2, strArg3;
+	strArg1 <<"--hcertclients=" << aFileName.str() << ".txt";   
+	
+	strArg2<< "--bcertclients=" << aFileName.str() << ".dat"; 
+	cout <<"string value is " << strArg2.str().c_str() << endl;	
+	
+	string argument1, argument2;
+	const char *argv_certclient[3];
+	
+	argument1= strArg1.str().c_str();
+	argument2= strArg2.str().c_str();
+
+	argv_certclient[0] = argument1.c_str(); // --hcertclients=tbad_certclients_x.txt
+	argv_certclient[1] = "--out";			//--out
+	argv_certclient[2] = argument2.c_str(); //--bcertclients=t_certclients_x.dat
+
+	char *argument_ptr[3]; 
+	int argCount3 = 3;
+	char **argv;
+	for(int n = 0; n<argCount3; n++)
+		{
+		argument_ptr[n] = const_cast<char*>(argv_certclient[n]);
+		argv = argument_ptr;   
+		}
+	RunCertAppToolForBadParams(argCount3, argv, aFileName); 
+}
+
+
+/**
+Generate  config file for swicert
+*/
+void BadSwiCertTests(const stringstream &aFileName, int aIndex)
+{
+	const char **swicertPtr1; 
+	int count = 0 ;
+	switch(aIndex)
+	{
+	case 0:
+		{
+		// Tests for BadLabels
+		for(swicertPtr1= badswicert_array[aIndex]; *swicertPtr1; ++swicertPtr1)
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;
+			}
+		break;
+		}
+
+	case 1:
+		{
+		//Tests for BadFormats
+		for(swicertPtr1 = badswicert_array[aIndex]; *swicertPtr1; ++swicertPtr1)
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(0,*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;
+			}
+		break;
+		}
+	case 2:
+		{
+		//Tests for BadCertOwnerTypes
+		for(swicertPtr1 = badswicert_array[aIndex]; *swicertPtr1; ++swicertPtr1)
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(0,0,*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;
+			}
+		break;
+		}
+	case 3:
+		{
+		//Tests for BadSubjectKeyIds
+		for(swicertPtr1 = badswicert_array[aIndex]; *swicertPtr1; ++swicertPtr1)
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(0,0,0,*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;	
+			}
+		break;
+		}
+	case 4:
+		{
+		//Tests for BadIssuerKeyIds
+		for(swicertPtr1 = badswicert_array[aIndex]; *swicertPtr1; ++swicertPtr1)
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(0,0,0,0,*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;
+			}
+		break;
+		}
+	case 5:
+		{
+		//Tests for BadApplications
+		swicertPtr1 = badswicert_array[aIndex];
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(0,0,0,0,0,*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;
+			}
+		break;
+		}
+	case 6:
+		{
+		//Tests for BadTrusteds
+		for(swicertPtr1 = badswicert_array[aIndex]; *swicertPtr1; ++swicertPtr1)
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(0,0,0,0,0,0,*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;
+			}
+		break;
+		}
+	case 7:
+		{
+		//Tests for BadDataFileName
+		for(swicertPtr1 = badswicert_array[aIndex]; *swicertPtr1; ++swicertPtr1)
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(0,0,0,0,0,0,0,*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;
+			}
+		break;
+		}
+	case 8:
+		{
+		//Tests for BadCapabilities
+		swicertPtr1 = badswicert_array[aIndex];
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(0,0,0,0,0,0,0,0,*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;
+			}
+		break;
+		}
+	case 9:
+		{
+		//Tests for BadMandatory
+		for(swicertPtr1 = badswicert_array[aIndex]; *swicertPtr1; ++swicertPtr1)
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(0,0,0,0,0,0,0,0,0,*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;
+			}
+		break;
+		}
+	case 10:
+		{
+		//Tests for BadSystemUpgrade
+		for(swicertPtr1 = badswicert_array[aIndex]; *swicertPtr1; ++swicertPtr1)
+			{
+			stringstream file1, file2;
+			file1 << aFileName.str() <<"_"<<count;
+			file2 << aFileName.str() <<"_"<<count <<".txt";
+			SwiBadCertStoreConfigWriter badswiWriter(file2);
+			badswiWriter.WriteSwiEntry(0,0,0,0,0,0,0,0,0,0,*swicertPtr1);
+			TestBadConfigFiles(file1,1);
+			count++;
+			}
+		break;
+		}
+	default:
+		break;
+	}
+}
+
+/**
+Test cases to test the tool with empty configuration files as input for all the stores
+*/
+void TestsWithEmptyConfigFile()
+{
+	for(int i = 0 ; i<3 ; i++)
+		{
+		stringstream emptyConfigFileName, configFileName1, configFileName2;
+		emptyConfigFileName<< "SDP-Security_Tools-CertApp-EmptyFile_000"<< i <<".txt";
+		switch(i)
+			{
+			case 0:
+				{
+				configFileName1 << "--hcertclients=" << emptyConfigFileName.str();
+				configFileName2 << "--bcertclients=SDP-Security_Tools-CertApp-EmptyFile_0000"<<".dat";
+				FileCertClientConfigWriter certclient(emptyConfigFileName);
+				}
+			break;
+
+			case 1:
+				{
+				configFileName1 << "--hfilecertstore=" << emptyConfigFileName.str();
+				configFileName2 << "--bfilecertstore=SDP-Security_Tools-CertApp-EmptyFile_0001"<<".dat";
+				FileCertStoreConfigWriter fileWriter(emptyConfigFileName);
+				}
+			break;
+
+			case 2:
+				{
+				configFileName1 << "--hswicertstore=" << emptyConfigFileName.str();
+				configFileName2 << "--bswicertstore=SDP-Security_Tools-CertApp-EmptyFile_0002"<<".dat";
+				SwiCertStoreConfigWriter swiFileWriter(emptyConfigFileName);
+				}
+			break;
+
+			default:
+				break;
+			}
+
+		string argument1, argument2;
+		argument1  = configFileName1.str().c_str();
+		argument2  = configFileName2.str().c_str();
+		const char *argv_certclient[4];
+		argv_certclient[0] = "--hcertclients=SDP-Security_Tools-CertApp-CCDAT_0000.txt";
+		argv_certclient[1] = argument1.c_str();  //"--hfilecertstore=t_emptyConfig.txt";
+		argv_certclient[2] = "--out";
+		argv_certclient[3] = argument2.c_str();
+
+		int argcount = 4;
+		char *argument_ptr[4]; 
+		char **argv;
+		for(int n = 0; n<argcount; n++)
+			{
+			argument_ptr[n] = const_cast<char*>(argv_certclient[n]);
+			argv = argument_ptr;
+			}
+		for(int z=0; z<argcount; z++)
+			{
+			cout << "Testing with empty configuration file" << argv[z] <<endl;
+			}
+
+		RunCertAppTool(argcount, argv, emptyConfigFileName);
+		}
+}
+
+/**
+Code to test the certapp tool for different file encode formats
+*/
+void TestsWithEncodedFileFormats()
+{
+	//Provide files with different encoded formats
+	for(int i = 0; i<4; i++)
+		{
+		stringstream unicodeName, outputFileName, strArg3;
+		const char *argv_certclient[KIndex];
+		unicodeName<< fileEncodeType[i];
+		outputFileName <<"SDP-Security_Tools-CertApp-FileFormats-000" <<i;
+		strArg3 << "--bfilecertstore="<< "SDP-Security_Tools-CertApp-FileFormats-000" <<i<<".dat";
+		
+		string argument;
+		argument = strArg3.str().c_str();
+		argv_certclient[0] = "--hcertclients=SDP-Security_Tools-CertApp-CCDAT_0000.txt";
+		argv_certclient[1] = fileEncodeType[i];   // manually created unicode content files
+		argv_certclient[2] = "--out";
+		argv_certclient[3] = argument.c_str();
+
+		for(int m=0; m<KIndex; m++)
+			{
+			cout << "Value in argv_certclient " << m << "is " <<argv_certclient[m] <<endl;
+			}
+		 char *argument_ptr[4]; 
+		char **argv;
+		for(int n = 0; n<KIndex; n++)
+			{
+			argument_ptr[n] = const_cast<char*>(argv_certclient[n]);
+			argv = argument_ptr;
+			}
+		
+		for(int z=0; z<KIndex; z++)
+			{
+			cout << "Argument array contains : " << argv[z] <<endl;
+			}
+		
+		int ret = RunCertApp(progress, errors, KIndex, argv); 
+		cout << "Return value from RunCertApp tool is "  << ret << endl;
+		
+		if(ret!= 0 && ((strcmp(unicodeName.str().c_str(),"--hfilecertstore=ucs2-bigendian.txt")==0) || (strcmp(unicodeName.str().c_str(),"--hfilecertstore=ucs2-littleendian.txt")==0)))
+			{
+			passCount++;
+			file<< "Tool doesnt support for UCS encoded file-"<< outputFileName.str() <<" so the result is " << ret << " Pass" << endl ;
+			}
+		else if(ret== 0 && ((strcmp(unicodeName.str().c_str(),"--hfilecertstore=utf8.txt") ==0) || (strcmp(unicodeName.str().c_str(),"--hfilecertstore=utf8_without_bom.txt")==0)))
+			{
+			passCount++;
+			file << "No Error in creating store for UTF8 encoded file-"<<outputFileName.str()<< " and result is " << ret << " Pass" <<endl ;
+			}
+		} //End of encoded file formats testing
+}
+
+/**
+Test case for REQ-10314 (Reviewing Aggregate Certificate DataBase)
+*/
+void TestToReviewingAggregateStore()
+{
+	for(int index = 0; index<2; index++)
+		{
+		stringstream file1, file2;
+		const char *argv_certclient[4];
+		argv_certclient[2] = "--out";
+		switch(index)
+			{
+			case 0: // different certificate labels in two stores
+				{
+				argv_certclient[0] = "--bfilecertstore=teststore1.dat";   // these are 2 binary stores saved in perforce
+				argv_certclient[1] = "--bfilecertstore=teststore3.dat"; 
+				argv_certclient[3] = "--hfilecertstore=SDP-Security_Tools-CertApp-AggrCertStore-0000.txt";
+				file1 <<"SDP-Security_Tools-CertApp-AggrCertStore-0000.txt";
+				file2 <<"aggregatestorecontents1_3.txt";
+				}
+				break;
+
+			case 1: //duplicate certificate labels in two stores
+				{
+				argv_certclient[0] = "--bfilecertstore=teststore2.dat";   // these are 2 binary stores saved in perforce
+				argv_certclient[1] = "--bfilecertstore=teststore3.dat"; 
+				argv_certclient[3] = "--hfilecertstore=SDP-Security_Tools-CertApp-AggrCertStore-0001.txt";
+				file1 <<"SDP-Security_Tools-CertApp-AggrCertStore-0001.txt";
+				file2 <<"aggregatestorecontents2_3.txt";
+				}
+				break;
+
+			default:
+				break;
+			}
+
+		for(int m=0; m<KIndex; m++)
+			{
+			cout << "Value in argv_certclient " << m << "is " <<argv_certclient[m] <<endl;
+			}
+		char *argument_ptr[KIndex]; 
+		char **argv;
+		for(int n = 0; n<KIndex; n++)
+			{
+			argument_ptr[n] = const_cast<char*>(argv_certclient[n]);
+			argv = argument_ptr;
+			}
+		
+		int ret = RunCertApp(progress, errors, KIndex, argv); 
+		if(!ret)
+			{
+			passCount++;
+			int compareValue  = CompareFiles(file1,file2); // compare with the reference files in perforce
+			if (compareValue)
+				{
+				file << "Failed to successfully create Aggregate Database for " << file1.str() << " is Fail" <<endl;
+				}
+			else
+				{
+				file << "Successfully created Aggregate Database(text form) for " <<file1.str() << " result is Pass" <<endl;
+				}
+			}
+		else
+			{
+			failCount++;
+			file << "Failed to dump the stores to single text format for " <<file1.str() <<endl;
+			}
+		}
+}
+
+
+/**
+TestCase to test the req of 10313- decode/encode certstore
+Encode-decode test for certclient store
+*/
+void TestToDecodeAndEncodeStore()
+{
+	stringstream outputFileName, strArg1, strArg2;
+	outputFileName <<"SDP-Security_Tools-CertApp-DecodeEncode-0000";
+	strArg1 << "decodeoutput1.txt";
+	strArg2 << "decodeoutput2.txt";
+	
+	const char *argv_certclient[3]; //dump store to text
+	argv_certclient[0] = "--bcertclients=certclients_0.dat";
+	argv_certclient[1] = "--out";
+	argv_certclient[2] = "--hcertclients=decodeoutput1.txt";   
+	decodeEncodeCertAppCall(argv_certclient);
+
+	//create store with the decoded text as input
+	argv_certclient[0] = "--hcertclients=decodeoutput1.txt";
+	argv_certclient[2] = "--bcertclients=decodeoutput.dat";   
+	decodeEncodeCertAppCall(argv_certclient);
+
+	//take the encoded store and dump it back to text form
+	argv_certclient[0] = "--bcertclients=decodeoutput.dat";
+	argv_certclient[2] = "--hcertclients=decodeoutput2.txt"; 
+	decodeEncodeCertAppCall(argv_certclient);
+
+	int compVal = CompareFiles(strArg1, strArg2);
+	cout << "Return value of comparision is " << compVal <<endl;
+	if (compVal)
+		{
+		failCount++;
+		file << "Encode-Decode fail for " <<outputFileName.str() << " result is Fail" <<endl;
+		}
+	else
+		{
+		passCount++;
+		file << "Encode-Decode Pass for " <<outputFileName.str() << " result is Pass" <<endl;
+		}
+}
+
+void decodeEncodeCertAppCall(const char *aArray[])
+{
+	char *argument_ptr[3]; 
+	char **argv;
+	for(int m=0; m<3; m++)
+		{
+		cout << "Value in argv_certclient " << m << "is " <<aArray[m] <<endl;
+		}
+	for(int n = 0; n<3; n++)
+		{
+		argument_ptr[n] = const_cast<char*>(aArray[n]);
+		argv = argument_ptr;
+		}
+	RunCertApp(progress, errors ,3, argv);
+}
+
+
+int CompareFiles(stringstream &aFile1, stringstream &aFile2)
+{
+	ifstream inFile1, inFile2;
+	string name1 = aFile1.str();
+	string name2 = aFile2.str();
+	inFile1.open(name1.c_str(),  ifstream::in);
+	if (inFile1.fail())
+		{
+		cout << "Failed to open the file! May be not existing" << endl;
+		return -1;
+		}
+	inFile2.open(name1.c_str(),  ifstream::in);
+	if (inFile2.fail()) 
+		{
+	    cout << "Failed to open the file! May be not existing" << endl;
+	    return -1;
+		}
+	return Compare(inFile1, inFile2);
+}
+
+
+int Compare(istream &aIstream1, istream &aIstream2)
+{
+  char ch1, ch2;
+  while (aIstream1.get(ch1)) 
+  {
+    if (!aIstream2.get(ch2) || (ch1 != ch2))
+	{
+      cout << "files are not equal";
+	  return -1;
+    }
+  }
+  if (!aIstream2.get(ch2))  // no more chars to read fom file
+	{
+	  cout << "files are equal\n";
+	  return 0;
+	}
+  else 
+	{
+	  cout << "files are not equal";
+	  return -1;
+	}
+}
+
+
+/**
+Generate script files for the filecertstore emulator tests
+*/
+void GenerateGoodCertClientTestScripts(const stringstream &aFilename)
+{
+	CertClientsStoreScriptGeneration cert_clients(aFilename);
+
+	cert_clients.WriteInitialiseCertClient();
+	cert_clients.WriteGetCount(KAppUidIndex);
+	cert_clients.WriteGetApplicationsList();
+	
+	for(int i = 0; i<KAppUidIndex;i++)
+		{
+		const char *goodlabel = goodcertclient_array[i]; 
+		const char *uid = gooddecimalUid_array[i];
+		cert_clients.WriteGetAppWithUid(goodlabel, uid);
+		}
+	cert_clients.WriteDestroyManager();
+}
+
+/**
+Generates config files for cacerts
+*/
+void GenerateGoodCaCertsTestScripts(const stringstream &aFilename)
+{
+	FileStoreScriptGeneration fileStore(aFilename);
+
+	const char *mode = "write"; 
+	const char *ownertype = goodOwnerType[0]; //CA ownerType
+
+	fileStore.WriteInitialiseCert(mode);
+	fileStore.WriteListcert(ownertype);
+	
+	for(int i = 0; i<6;i++)
+		{
+		const char *trust = goodTrust[0]; // true
+		const char *goodlabel = goodEmuCert_array[i]; // list of label - root5ca , symbiandtestcsa, symbiantestrcsa
+
+		fileStore.WriteGetCertificateDetails(goodlabel);
+		fileStore.WriteGetTrust(goodlabel,trust);
+		fileStore.WriteGetApplications(goodlabel);
+		fileStore.WriteRetrieveCerts(goodlabel);
+		}
+}
+
+/**
+Generate script files for the swicertstore emulator tests
+*/
+void GenerateGoodSwiCertTestScripts(const stringstream &aFilename)
+{
+	SWIStoreScriptGeneration swiStore(aFilename);
+	
+	const char *ownertype = goodOwnerType[0]; //CA ownerType
+	
+	//initilaise the store and get list all the certificate ones
+	swiStore.WriteInitialiseCert();
+	swiStore.WriteListcert(ownertype);
+
+	for(int i = 0; i<6;i++)
+		{
+		const char *trust = goodTrust[0]; // true
+		const char *goodlabel = goodSwiCert_array[i]; // list of label - root5ca , symbiandtestcsa, symbiantestrcsa
+		const char *mandatoryVal = mandatory[0];
+		const char *systemupgrade = systemUpgrade[0];
+
+		swiStore.WriteGetSystemUpgrade(goodlabel,systemupgrade);
+		swiStore.WriteRetrieveCerts(goodlabel);
+		swiStore.WriteGetApplications(goodlabel);
+		swiStore.WriteGetTrust(goodlabel,trust);
+		swiStore.WriteGetCapabilities(goodlabel);
+		swiStore.WriteGetMandatoryFlag(goodlabel, mandatoryVal);
+		}
+}
+
+//End of file