MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/graphics/printingservices/printerdriversupport/tps/T_PDRMEM.CPP
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 1996-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "T_PDRMEM.H"

    17 

    18 _LIT( KDriveName, "z:" );

    19 _LIT( KEpsonFileName, "epson.pdr" );

    20 

    21 

    22 class CTPdrMem : public CTGraphicsBase

    23 	{

    24 public:

    25 	CTPdrMem(CTestStep* aStep);

    26 protected:

    27 //from 	CTGraphicsStep

    28 	virtual void RunTestCaseL(TInt aCurTestCase);

    29 private:

    30 	void TestNewL();

    31 	void TestOpenPdrL();

    32 	void TestCreatePrinterDeviceL();

    33 	};

    34 

    35 CTPdrMem::CTPdrMem(CTestStep* aStep) :

    36 	CTGraphicsBase(aStep)

    37 	{

    38 	

    39 	}

    40 

    41 void CTPdrMem::RunTestCaseL(TInt aCurTestCase)

    42 	{

    43 	TInt ret;

    44 	((CTPdrMemStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

    45 	switch(aCurTestCase)

    46 		{

    47 	case 1:

    48 /**

    49 @SYMTestCaseID			GRAPHICS-PDRMEM-0001

    50 */

    51 		((CTPdrMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-PDRMEM-0001"));

    52 		TRAP(ret,TestNewL());

    53 		TEST(ret==KErrNone);

    54 		break;

    55 	case 2:

    56 /**

    57 @SYMTestCaseID			GRAPHICS-PDRMEM-0002

    58 */

    59 		((CTPdrMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-PDRMEM-0002"));

    60 		TRAP(ret,TestOpenPdrL());

    61 		TEST(ret==KErrNone);

    62 		break;

    63 	case 3:

    64 /**

    65 @SYMTestCaseID			GRAPHICS-PDRMEM-0003

    66 */

    67 		((CTPdrMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-PDRMEM-0003"));

    68 		TRAP(ret,TestCreatePrinterDeviceL());

    69 		TEST(ret==KErrNone);

    70 		break;

    71 	case 4:

    72 		((CTPdrMemStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

    73 //		TRAP(ret,testGetNearestFontToDesignHeightInTwips());

    74 //		TEST(ret==KErrNone);

    75 		break;

    76 	case 5:

    77 		((CTPdrMemStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

    78 		((CTPdrMemStep*)iStep)->CloseTMSGraphicsStep();

    79 		TestComplete();

    80 		break;

    81 		}

    82 	((CTPdrMemStep*)iStep)->RecordTestResultL();

    83 	}

    84 

    85 void CTPdrMem::TestNewL()

    86 	{

    87 	INFO_PRINTF1(_L("NewL"));

    88 	

    89 	TInt ret=KErrGeneral;

    90 	CPrinterDriver *driver=NULL;

    91 	TInt failRate=1;

    92 

    93 	while (ret!=KErrNone)

    94 		{

    95 		__UHEAP_RESET;

    96 		__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);

    97 		__UHEAP_MARK;

    98 		TRAP(ret,driver=CPrinterDriver::NewL());

    99 		RDebug::Print(_L("driver %d failrate %d\n"),driver,failRate);

   100 		if (ret==KErrNoMemory)

   101 			{

   102 			__UHEAP_MARKEND;

   103 			__UHEAP_RESET;

   104 			TEST(driver==NULL);

   105 			}

   106 		else if(ret==KErrNone)

   107 			{

   108 			delete driver;

   109 			__UHEAP_MARKEND;

   110 			__UHEAP_RESET;

   111 			__UHEAP_SETFAIL(RHeap::ENone,failRate);

   112 			}

   113 		else

   114 			User::Panic(_L("Unknown error"),ret);

   115 		failRate++;

   116 		}

   117 	}

   118 

   119 void CTPdrMem::TestOpenPdrL()

   120 	{

   121 	INFO_PRINTF1(_L("OpenPdrL"));

   122 	TInt failRate=1;

   123 	CPrinterDriver* driver=CPrinterDriver::NewL();

   124 	TFileName filename( KDriveName );

   125 	filename.Append( KDefaultPrinterDriverPath );

   126 	filename.Append( KEpsonFileName );

   127 	driver->OpenPdrL( filename );

   128 	driver->Close();

   129 	TInt ret=KErrGeneral;

   130 

   131 	while (ret!=KErrNone)

   132 		{

   133 		__UHEAP_RESET;

   134 		__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);

   135 		__UHEAP_MARK;

   136 		TRAP(ret,driver->OpenPdrL( filename ));

   137 		RDebug::Print(_L("NumModels %d failrate %d\n"),driver->NumModels(), failRate);

   138 		if (ret==KErrNoMemory)

   139 			{

   140 			driver->Close();

   141 			__UHEAP_MARKEND;

   142 			__UHEAP_RESET;

   143 			TEST(driver->NumModels()==0);

   144 			}

   145 		else if(ret==KErrNone)

   146 			{

   147 			driver->Close();

   148 			__UHEAP_MARKEND;

   149 			__UHEAP_RESET;

   150 			__UHEAP_SETFAIL(RHeap::ENone,failRate);

   151 			}

   152 		else

   153 			User::Panic(_L("Unknown error"),ret);

   154 		failRate++;

   155 		}

   156 			

   157 	delete driver;

   158 

   159 	}

   160 

   161 void CTPdrMem::TestCreatePrinterDeviceL()

   162 	{

   163 

   164 	INFO_PRINTF1(_L("CreatePrinterDeviceL"));

   165 	TInt failRate=1;

   166 	CPrinterDriver* driver=CPrinterDriver::NewL();

   167 	TFileName filename( KDriveName );

   168 	filename.Append( KDefaultPrinterDriverPath );

   169 	filename.Append( KEpsonFileName );

   170 	driver->OpenPdrL( filename );

   171 	TPrinterModelEntry entry;

   172 	entry=driver->Model(0);

   173 	RDebug::Print(_L("Drivers: %d\r\n"), driver->NumModels());

   174 	RDebug::Print(_L("Model %d: %d\r\n"), 0, entry.iUid.iUid);

   175 	CPrinterDevice* device=NULL;

   176 	TInt ret=KErrGeneral;

   177 

   178 	while(ret!=KErrNone)

   179 		{

   180 		__UHEAP_RESET;

   181 		__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);

   182 		__UHEAP_MARK;

   183 		TRAP(ret,device=driver->CreatePrinterDeviceL(entry.iUid));

   184 		RDebug::Print(_L("device %d failrate %d\n"),device, failRate);

   185 		if (ret==KErrNoMemory)

   186 			{

   187 			__UHEAP_MARKEND;

   188 			__UHEAP_RESET;

   189 			TEST(device==NULL);

   190 			}

   191 		else if	(ret==KErrNone)

   192 			{

   193 			__UHEAP_RESET;

   194 			__UHEAP_SETFAIL(RHeap::ENone,failRate);

   195 			}

   196 		else

   197 			User::Panic(_L("Unknown error"),ret);

   198 		failRate++;

   199 		}

   200 

   201 	delete driver;

   202   

   203 	}

   204 

   205 //This test is useless. 

   206 //It fails every time when calling device->GetNearestFontToDesignHeightInTwips().

   207 //device->GetNearestFontToDesignHeightInTwips() calls CFbsDrvDevice::LoadTypeFaceList()

   208 //which allocates additional memory for iGenTypefaceFontsType between

   209 //__UHEAP_MARK and __UHEAP_MARKEND macros.

   210 //CFbsDrvDevice takes care of deleting iGenTypefaceFontsType in its destructor.

   211 /*

   212 LOCAL_C void testGetNearestFontToDesignHeightInTwips()

   213 	{

   214 

   215 	INFO_PRINTF1(_L("GetNearestFontToDesignHeightInTwips"));

   216 	CPrinterDriver* driver=CPrinterDriver::NewL();

   217 	driver->OpenPdrL(_L("z:\\system\\printers\\epson.pdr"));

   218 	TInt failRate=1;

   219 	CFont *font;

   220 	TFontSpec spec;

   221 	spec.iTypeface.iName=_L("NewCourier");

   222 	spec.iHeight=100;

   223 	spec.iFontStyle.SetPosture(EPostureUpright);

   224 	spec.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);

   225 	spec.iFontStyle.SetPrintPosition(EPrintPosNormal);

   226 	TPrinterModelEntry entry;

   227 	entry=driver->Model(0);

   228 	CPrinterDevice* device=NULL;

   229 	TRAPD(ret,device=driver->CreatePrinterDeviceL(entry.iUid));

   230 	TEST(ret==KErrNone);

   231 	ret=device->GetNearestFontToDesignHeightInTwips((CFont *&) font,spec);

   232 	TEST(ret==KErrNone);

   233 	device->ReleaseFont(font);

   234 

   235 	ret=KErrGeneral;

   236 

   237 	while(ret!=KErrNone)

   238 		{

   239 		__UHEAP_RESET;

   240 		__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);

   241 		__UHEAP_MARK;

   242 		font=NULL;

   243 		ret = device->GetNearestFontToDesignHeightInTwips((CFont *&) font,spec);

   244 		INFO_PRINTF2(_L("Font %d failrate %d\n"),font,failRate);

   245 		if (ret==KErrNoMemory)

   246 			{

   247 			__UHEAP_MARKEND;

   248 			__UHEAP_RESET;

   249 			TEST(font==NULL);

   250 			}

   251 		else if	(ret==KErrNone)

   252 			{

   253 //			device->ReleaseFont(font);

   254 			font=NULL;

   255 			__UHEAP_RESET;

   256 			}

   257 		else

   258 			User::Panic(_L("Unknown error"),ret);

   259 		failRate++;

   260 		}

   261 

   262 	

   263 	delete driver;

   264 

   265 	test.End();

   266 	}

   267 */

   268 

   269 //--------------

   270 __CONSTRUCT_STEP__(PdrMem)

   271
Symaptic