diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/directgdi/test/tdirectgdidriver.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/directgdi/test/tdirectgdidriver.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,474 @@
+// Copyright (c) 2007-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:
+//
+
+#include "tdirectgdidriver.h"
+#include <graphics/directgdicontext.h>
+
+CTDirectGdiDriver::CTDirectGdiDriver()
+	{
+	SetTestStepName(KTDirectGdiDriverStep);
+	}
+
+CTDirectGdiDriver::~CTDirectGdiDriver()
+	{
+	}
+			
+/**
+@SYMTestCaseID
+	GRAPHICS-DIRECTGDI-DRIVER-0001
+
+@SYMPREQ	
+	PREQ39
+
+@SYMREQ
+	REQ9211 
+	REQ9226 
+	REQ9195
+	REQ9201 
+	REQ9202 
+	REQ9222 
+	REQ9223 
+	REQ9236 
+	REQ9237
+
+@SYMTestCaseDesc
+	Construction and destruction of a CDirectGdiDriver object.
+	Only one object should be created as its a singleton.
+	Open() should create the CDirectGdiDriverInternal object and increment the
+	reference count.
+	Close() should decrement the reference count and when it becomes zero, destroy
+	the CDirectGdiDriver & CDirectGdiDriverInternal object.
+
+@SYMTestActions
+	Open a driver.
+	Open a driver again.
+	Close a driver then open it again.
+	Close a driver, check that it is still open.
+	Close a driver, check that it is now closed.
+
+@SYMTestExpectedResults
+	A driver can be opened and closed successfully with no errors.
+
+@SYMTestStatus
+	Implemented
+*/
+void CTDirectGdiDriver::TestDriverL()
+	{
+	_LIT(KTestName, "Driver-TestDriver"); 
+	if(!iRunningOomTests)
+		{
+		INFO_PRINTF1(KTestName);
+		}
+	
+	// Check the driver returns NULL
+	CDirectGdiDriver* dgdiDriver = CDirectGdiDriver::Static();
+	TESTL(dgdiDriver == NULL);
+	
+	// Open the driver once
+	TInt res = CDirectGdiDriver::Open();		
+	TESTNOERRORL(res);		
+	
+	dgdiDriver = CDirectGdiDriver::Static();
+	TESTL(dgdiDriver != NULL);
+	
+	// Open the driver a second time
+	res = CDirectGdiDriver::Open();		
+	TESTNOERRORL(res);		
+	
+	// Close the driver once
+	dgdiDriver->Close();
+	
+	// Open the driver again
+	res = CDirectGdiDriver::Open();		
+	TESTNOERRORL(res);	
+			
+	// Close the driver twice, on the second close, the driver should delete 
+	// itself when its internal open count reaches zero
+	dgdiDriver->Close();
+	TESTL(CDirectGdiDriver::Static() != NULL);	
+	dgdiDriver->Close();
+	TESTL(CDirectGdiDriver::Static() == NULL);
+	}
+
+/**
+@SYMTestCaseID
+	GRAPHICS-DIRECTGDI-DRIVER-0002
+
+@SYMPREQ 
+	PREQ39
+
+@SYMREQ
+	REQ9211 
+	REQ9226 
+	REQ9195
+	REQ9201 
+	REQ9202 
+	REQ9222 
+	REQ9223 
+	REQ9236 
+	REQ9237
+
+@SYMTestCaseDesc
+	Out of memory test. Test that opening a driver does not cause memory leaks.
+
+@SYMTestActions
+	Repeatedly call the "Driver-ErrorCodes" test (below) in OOM conditions to make 
+	sure no memory leaks occur.
+
+@SYMTestExpectedResults
+	No memory leaks.
+	
+@SYMTestStatus
+	Implemented
+*/
+void CTDirectGdiDriver::TestDriverOOM()
+	{
+	TInt err, tryCount = 0;
+	INFO_PRINTF1(_L("Driver-TestDriverOOM"));
+
+	do
+		{
+		__UHEAP_FAILNEXT(++tryCount);
+		__UHEAP_MARK;
+		{
+		err = TestDriverErrorCodes();		
+		}
+		__UHEAP_MARKEND;
+		} 
+	while(err == KErrNoMemory);
+	if(err == KErrNone)
+		{
+		__UHEAP_RESET;
+		}
+	else
+		{
+		TEST(err == KErrNone);
+		}
+	INFO_PRINTF2(_L("- server succeeded at heap failure rate of %i\n"), tryCount);
+	}
+
+/**
+@SYMTestCaseID
+	GRAPHICS-DIRECTGDI-DRIVER-0003
+
+@SYMPREQ 
+	PREQ39
+
+@SYMREQ
+	REQ9211 
+	REQ9226 
+	REQ9195
+	REQ9201 
+	REQ9202 
+	REQ9222 
+	REQ9223 
+	REQ9236 
+	REQ9237
+
+@SYMTestCaseDesc
+	Checks the error code returned by GetError() after 	Construction and 
+	destruction of a CDirectGdiDriver object.
+
+@SYMTestActions
+	Create and destroy a CDirectGdiDriver.
+
+@SYMTestExpectedResults
+	Test that the only errors returned when opening a driver are KErrNone and
+	KErrNoMemory. Test that GetError() returns KErrNone after a driver has been opened.
+	
+@SYMTestStatus
+	Implemented
+*/
+TInt CTDirectGdiDriver::TestDriverErrorCodes()
+	{
+	_LIT(KTestName, "Driver-ErrorCodes"); 
+	if(!iRunningOomTests)
+		{
+		INFO_PRINTF1(KTestName);
+		}
+	
+	TInt errOpen = CDirectGdiDriver::Open(); 		
+	TEST( errOpen == KErrNone || errOpen == KErrNoMemory  );
+	if( errOpen != KErrNone )
+		return errOpen;
+	
+	CDirectGdiDriver* gdiDriver = CDirectGdiDriver::Static();
+	if( !gdiDriver )
+		return KErrNoMemory;	
+		
+	TInt err = gdiDriver->GetError();	
+	TESTNOERROR(err); 
+	gdiDriver->Close();	//Ref count should now be 0	
+	
+	return err;
+	}
+
+/**
+@SYMTestCaseID
+GRAPHICS-DIRECTGDI-0004
+
+@SYMPREQ PREQ39
+
+@SYMTestCaseDesc
+	Sets the error code and then checks the error code by calling GetError().
+	Setting the error code should not affect the actual error code, unless GetError() is first called to reset the error code.
+
+@SYMTestActions
+	Test the error setting and reporting functionality of the driver.
+	Set the error code twice with different errors each time,
+	get the error - the error returned should be the first error set, not the second.
+
+@SYMTestExpectedResults
+	Error code should be KErrGeneral and not KErrNoMemory.
+*/
+void CTDirectGdiDriver::TestSetError()
+	{
+	_LIT(KTestName, "Driver-SetError"); 
+	if(!iRunningOomTests)
+		{
+		INFO_PRINTF1(KTestName);
+		}
+	
+	TInt errOpen  = CDirectGdiDriver::Open(); 	
+	TEST( errOpen == KErrNone || errOpen == KErrNoMemory  );
+	
+	CDirectGdiDriver* gdiDriver = CDirectGdiDriver::Static();
+	TEST(gdiDriver!=NULL);	
+	
+	gdiDriver->SetError(KErrGeneral);	
+	gdiDriver->SetError(KErrNoMemory);	
+
+	TInt err = gdiDriver->GetError();	
+	TEST(err == KErrGeneral); 
+
+	gdiDriver->Close();	//Ref count should now be 0	
+	}
+
+/**
+@SYMTestCaseID
+GRAPHICS-DIRECTGDI-0005
+
+@SYMPREQ PREQ39
+
+@SYMTestCaseDesc
+	Tests the function Flush()
+
+@SYMTestActions
+	Open a DirectGDI driver
+	Call Flush()
+	Close the driver.
+
+@SYMTestExpectedResults
+	On software DirectGDI, Flush() does not do anything but on hardware DirectGDI, it calls vgFlush().
+	No error should occur.
+*/
+void CTDirectGdiDriver::TestFlush()
+	{
+	_LIT(KTestName, "Driver-TestFlush"); 
+	if(!iRunningOomTests)
+		{
+		INFO_PRINTF1(KTestName);
+		}	
+	TInt errOpen  = CDirectGdiDriver::Open(); 	
+	TEST(errOpen == KErrNone);	
+	CDirectGdiDriver* gdiDriver = CDirectGdiDriver::Static();
+	TEST(gdiDriver!=NULL);		
+	gdiDriver->Flush();
+	TInt err = gdiDriver->GetError();	
+	TEST(err == KErrNone); 
+	gdiDriver->Close();	//Ref count should now be 0	
+	}
+
+/**
+@SYMTestCaseID
+GRAPHICS-DIRECTGDI-0006
+
+@SYMPREQ PREQ39
+
+@SYMTestCaseDesc
+	Test that CDirectGdiDriver::GetInterface() returns KErrExtensionNotSupported
+	when a non-existent extension interface is requested.
+
+@SYMTestActions
+	Open a DirectGDI driver.
+	Request a extension interface using the Uif 0xFFFFFFFF.		
+
+@SYMTestExpectedResults
+	KErrExtensionNotSupported should be returned and the requested interface pointer
+	should be set to NULL.
+ */
+void CTDirectGdiDriver::TestGetInterfaceL()
+	{
+	_LIT(KTestName, "Driver-TestGetInterfaceL"); 
+	if(!iRunningOomTests)
+		{
+		INFO_PRINTF1(KTestName);
+		}	
+	
+	TInt err = CDirectGdiDriver::Open(); 	
+	TESTNOERRORL(err);
+	
+	CDirectGdiDriver* driver = CDirectGdiDriver::Static();
+	TESTL(driver != NULL);
+	
+	// Set badInterface to something other than NULL to make sure GetInterface is setting it to NULL
+	TAny* badInterface = &err; 
+	err = driver->GetInterface(TUid::Uid(0xFFFFFFFF), badInterface);
+	TEST(err == KErrExtensionNotSupported);
+	TEST(badInterface == NULL);
+	
+	driver->Close();
+	}
+
+/**
+@SYMTestCaseID
+GRAPHICS-DIRECTGDI-0007
+
+@SYMPREQ PREQ39
+
+@SYMTestCaseDesc
+	Tests the MDirectGdiDriverCacheSize extension interface implementation provided
+	by CDirectGdiDriver. Note that this extension is only implemented by the hardware
+	DirectGdi adaptation, it is not provided by the software adaptation.
+
+@SYMTestActions
+	if testing on hardware DirectGdi:
+		Open a DirectGDI driver.
+		Attempt to get the extension interface for MDirectGdiDriverCacheSize from the driver.
+			- This should succeed.
+		Get the currently set maximum image cache and glyph cache size.
+		Set the new image and glyph cache sizes to less than the current size.
+		Set the new image and glyph cache sizes to greater than the current size.
+		Check that the reported image/glyph cache sizes are correctly set.
+			
+	if testing on software DirectGdi:
+		Open a DirectGdi driver.
+		Attempt to get the extension interface for MDirectGdiDriverCacheSize from the driver.
+			- This should fail.		
+
+@SYMTestExpectedResults
+    Setting the caches to a smaller size that the existing size should cause KErrArgument to be returned.
+    All other APIs should succeed.
+    If using Software DirectGDI, it should skip the tests.
+ */
+void CTDirectGdiDriver::TestCacheSizesL()
+	{
+	_LIT(KTestName, "Driver-TestCacheSizes"); 
+	if(!iRunningOomTests)
+		{
+		INFO_PRINTF1(KTestName);
+		}	
+	
+	TInt err = CDirectGdiDriver::Open(); 	
+	TESTNOERRORL(err);
+	
+	CDirectGdiDriver* driver = CDirectGdiDriver::Static();
+	TESTL(driver != NULL);
+	CleanupClosePushL(*driver);
+	
+	MDirectGdiDriverCacheSize* driverCacheInterface = NULL;
+	err = driver->GetInterface(TUid::Uid(KDirectGdiDriverCacheSizeUid), (TAny*&)driverCacheInterface);
+	if (err == KErrNone)
+		{
+		// MDirectGdiDriverCacheSize is implemented in the hardware (VG) adaptation
+		TESTL(driverCacheInterface != NULL);
+		
+		// This number must be > the default image cache size for this test to pass.
+		const TInt KLargeImageCacheSize = 0x500000; 
+		// This number must be > the default glyph cache size for this test to pass.
+		const TInt KLargeGlyphCacheSize = 0x500000;
+		
+		TESTNOERROR(driverCacheInterface->SetMaxImageCacheSize(KLargeImageCacheSize));
+		TESTNOERROR(driverCacheInterface->SetMaxGlyphCacheSize(KLargeGlyphCacheSize));
+		
+		// Test the image cache size
+		TEST(KErrArgument == driverCacheInterface->SetMaxImageCacheSize(-1));
+		TESTNOERROR(driverCacheInterface->SetMaxImageCacheSize(KLargeImageCacheSize+1));
+		TEST(driverCacheInterface->MaxImageCacheSize() == KLargeImageCacheSize+1);
+				
+		// Test the glyph cache size
+		TEST(KErrArgument == driverCacheInterface->SetMaxGlyphCacheSize(-1));
+		TESTNOERROR(driverCacheInterface->SetMaxGlyphCacheSize(KLargeGlyphCacheSize+1));
+		TEST(driverCacheInterface->MaxGlyphCacheSize() == KLargeGlyphCacheSize+1);
+		}
+	else
+		{
+		// MDirectGdiDriverCacheSize is not implemented in the software adaptation of DirectGDI.
+		// The only error code that should be returned is KErrExtensionNotSupported.
+		TEST(err == KErrExtensionNotSupported);
+		TEST(driverCacheInterface == NULL);
+		INFO_PRINTF1(_L("Extension MDirectGdiDriverCacheSize not supported, skipping test."));
+		}
+	
+	CleanupStack::PopAndDestroy(1, driver);
+	}
+
+/**
+Override of base class virtual
+
+@return - TVerdict code
+*/
+TVerdict CTDirectGdiDriver::doTestStepPreambleL()
+	{			
+	CTDirectGdiStepBase::doTestStepPreambleL();	
+	INFO_PRINTF1(_L("DirectGdi Driver pre-test setup"));
+	return TestStepResult();
+	}
+	
+/** 
+Override of base class pure virtual
+Our implementation only gets called if the base class doTestStepPreambleL() did
+not leave. That being the case, the current test result value will be EPass.
+
+Creates background window with black & white checker board. 
+This background windows is used for each test case in this file
+
+@return TVerdict code
+*/	
+TVerdict CTDirectGdiDriver::doTestStepL()
+	{		
+	INFO_PRINTF1(_L("DirectGdi Driver Test" ));
+	if (iUseDirectGdi)
+		{
+		RunTestsL();			
+		}	
+	return TestStepResult();
+	}
+
+void CTDirectGdiDriver::RunTestsL()
+	{
+	SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRIVER-0001"));
+	TestDriverL();
+	RecordTestResultL();
+	SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRIVER-0003"));
+	TestDriverErrorCodes();
+	RecordTestResultL();
+	SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRIVER-0002"));
+	TestDriverOOM();	
+	RecordTestResultL();
+	SetTestStepID(_L("GRAPHICS-DIRECTGDI-0004"));
+	TestSetError();
+	RecordTestResultL();
+	SetTestStepID(_L("GRAPHICS-DIRECTGDI-0005"));
+	TestFlush();
+	RecordTestResultL();
+	SetTestStepID(_L("GRAPHICS-DIRECTGDI-0006"));
+	TestGetInterfaceL();
+	RecordTestResultL();
+	SetTestStepID(_L("GRAPHICS-DIRECTGDI-0007"));
+	TestCacheSizesL();
+	RecordTestResultL();
+	CloseTMSGraphicsStep();
+	}