Added two macros to call tests for all drivers, or for all hw drivers, with just one call.

Added tests to check whether the driver supports the necessary features, and stop early if it does not make sense.
Fixed line endings for testXML.cpp

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@3819 dfc29bdd-3216-0410-991c-e03cc46cb475

tests/2dmaterial.cpp

@@ -645,6 +645,16 @@ static bool draw2DImage4c(video::E_DRIVER_TYPE type)
 
 	video::IVideoDriver* driver = device->getVideoDriver();
 
+	if (!driver->queryFeature(video::EVDF_BILINEAR_FILTER))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
     driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS,true);
     driver->setTextureCreationFlag(video::ETCF_OPTIMIZED_FOR_QUALITY,true);
 
@@ -739,6 +749,16 @@ static bool addBlend2d(video::E_DRIVER_TYPE type)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager* smgr = device->getSceneManager();
 
+	if (!driver->queryFeature(video::EVDF_BILINEAR_FILTER))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	scene::IAnimatedMesh* mesh = smgr->getMesh("../media/sydney.md2");
 	if (!mesh)
 	{
@@ -816,6 +836,16 @@ static bool moreFilterTests(video::E_DRIVER_TYPE type)
     video::IVideoDriver* driver = device->getVideoDriver();
     gui::IGUIEnvironment* gui = device->getGUIEnvironment();
 
+	if (!driver->queryFeature(video::EVDF_BILINEAR_FILTER))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
 	video::ITexture* tex = driver->getTexture("../media/irrlichtlogo.jpg");
     gui::IGUIImage* image = gui->addImage(core::recti(0,0,64,64));
@@ -857,20 +887,9 @@ static bool moreFilterTests(video::E_DRIVER_TYPE type)
 
 bool twodmaterial()
 {
-	bool result = addBlend2d(video::EDT_OPENGL);
-	result &= addBlend2d(video::EDT_DIRECT3D9);
-	result &= addBlend2d(video::EDT_DIRECT3D8);
-	result &= addBlend2d(video::EDT_BURNINGSVIDEO);
-
-	result &= moreFilterTests(video::EDT_OPENGL);
-	result &= moreFilterTests(video::EDT_DIRECT3D9);
-	result &= moreFilterTests(video::EDT_DIRECT3D8);
-	result &= moreFilterTests(video::EDT_BURNINGSVIDEO);
-
-	result &= draw2DImage4c(video::EDT_OPENGL);
-	result &= draw2DImage4c(video::EDT_DIRECT3D9);
-	result &= draw2DImage4c(video::EDT_DIRECT3D8);
-	result &= draw2DImage4c(video::EDT_BURNINGSVIDEO);
-
+	bool result = true;
+	TestWithAllDrivers(addBlend2d);
+	TestWithAllDrivers(moreFilterTests);
+	TestWithAllDrivers(draw2DImage4c);
 	return result;
 }

tests/anti-aliasing.cpp

@@ -25,6 +25,8 @@ static bool testLineRendering(video::E_DRIVER_TYPE type)
 		return true;
 	}
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	scene::ISceneManager* smgr = device->getSceneManager();
 
 	scene::IAnimatedMesh* mesh = smgr->getMesh("../media/sydney.md2");
@@ -62,7 +64,7 @@ static bool testLineRendering(video::E_DRIVER_TYPE type)
 
 bool antiAliasing()
 {
-	bool result = testLineRendering(video::EDT_OPENGL);
-	result &= testLineRendering(video::EDT_DIRECT3D9);
+	bool result = true;
+	TestWithAllHWDrivers(testLineRendering);
 	return result;
 }

tests/createImage.cpp

@@ -2,11 +2,11 @@
 
 using namespace irr;
 
-static bool testImageCreation(video::E_DRIVER_TYPE driverType)
+static bool testImageCreation()
 {
 	// create device
 
-	IrrlichtDevice *device = createDevice(driverType, core::dimension2d<u32>(160,120));
+	IrrlichtDevice *device = createDevice(video::EDT_SOFTWARE, core::dimension2d<u32>(160,120));
 
 	if (device == 0)
 		return true; // could not create selected driver.
@@ -37,6 +37,6 @@ static bool testImageCreation(video::E_DRIVER_TYPE driverType)
 
 bool createImage()
 {
-	bool result = testImageCreation(video::EDT_SOFTWARE);
+	bool result = testImageCreation();
 	return result;
 }

tests/draw2DImage.cpp

@@ -72,14 +72,8 @@ bool testWithPNG(video::E_DRIVER_TYPE driverType)
 
 bool draw2DImage()
 {
-	bool result = testWithRenderTarget(video::EDT_DIRECT3D9);
-	result &= testWithRenderTarget(video::EDT_DIRECT3D8);
-	result &= testWithRenderTarget(video::EDT_OPENGL);
-	result &= testWithRenderTarget(video::EDT_BURNINGSVIDEO);
-	result &= testWithRenderTarget(video::EDT_SOFTWARE);
-
-	result &= testWithPNG(video::EDT_DIRECT3D9);
-	result &= testWithPNG(video::EDT_OPENGL);
-
+	bool result = true;
+	TestWithAllDrivers(testWithRenderTarget);
+	TestWithAllHWDrivers(testWithPNG);
 	return result;
 }

tests/drawPixel.cpp

@@ -24,6 +24,8 @@ static bool lineRender(E_DRIVER_TYPE driverType)
 	IVideoDriver* driver = device->getVideoDriver();
 	ISceneManager * smgr = device->getSceneManager();
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	// Draw a cube background so that we can check that the pixels' alpha is working.
 	ISceneNode * cube = smgr->addCubeSceneNode(50.f, 0, -1, vector3df(0, 0, 60));
 	cube->setMaterialTexture(0, driver->getTexture("../media/wall.bmp"));
@@ -64,6 +66,8 @@ static bool pixelAccuracy(E_DRIVER_TYPE driverType)
 
 	IVideoDriver* driver = device->getVideoDriver();
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	device->getSceneManager()->addCameraSceneNode();
 
 	driver->beginScene(true, true, SColor(255,100,101,140));
@@ -108,30 +112,10 @@ static bool pixelAccuracy(E_DRIVER_TYPE driverType)
 
 bool drawPixel(void)
 {
-	bool passed = true;
-
-	logTestString("Check OpenGL driver\n");
-	passed &= lineRender(EDT_OPENGL);
-	logTestString("Check Software driver\n");
-	passed &= lineRender(EDT_SOFTWARE);
-	logTestString("Check Burning's Video driver\n");
-	passed &= lineRender(EDT_BURNINGSVIDEO);
-	logTestString("Check Direct3D9 driver\n");
-	passed &= lineRender(EDT_DIRECT3D9);
-	logTestString("Check Direct3D8 driver\n");
-	passed &= lineRender(EDT_DIRECT3D8);
-
-	logTestString("Check OpenGL driver\n");
-	passed &= pixelAccuracy(EDT_OPENGL);
-	logTestString("Check Software driver\n");
-	passed &= pixelAccuracy(EDT_SOFTWARE);
-	logTestString("Check Burning's Video driver\n");
-	passed &= pixelAccuracy(EDT_BURNINGSVIDEO);
-	logTestString("Check Direct3D9 driver\n");
-	passed &= pixelAccuracy(EDT_DIRECT3D9);
-	logTestString("Check Direct3D8 driver\n");
-	passed &= pixelAccuracy(EDT_DIRECT3D8);
-
-	return passed;
-}
+	bool result = true;
 
+	TestWithAllDrivers(lineRender);
+	TestWithAllDrivers(pixelAccuracy);
+
+	return result;
+}

tests/drawRectOutline.cpp

@@ -11,6 +11,8 @@ bool testWithDriver(video::E_DRIVER_TYPE driverType)
 
 	video::IVideoDriver* driver = device->getVideoDriver();
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	driver->beginScene(true, true, video::SColor(255,100,101,140));
 
 	core::recti r;
@@ -40,10 +42,7 @@ bool testWithDriver(video::E_DRIVER_TYPE driverType)
 bool drawRectOutline(void)
 {
 	// TODO: Only OpenGL supports thick lines
-	bool result = testWithDriver(video::EDT_BURNINGSVIDEO);
-	result &= testWithDriver(video::EDT_DIRECT3D8);
-	result &= testWithDriver(video::EDT_DIRECT3D9);
-	result &= testWithDriver(video::EDT_OPENGL);
-	result &= testWithDriver(video::EDT_SOFTWARE);
+	bool result = true;
+	TestWithAllDrivers(testWithDriver);
 	return result;
 }

tests/guiDisabledMenu.cpp

@@ -14,7 +14,7 @@ using namespace gui;
 
 bool guiDisabledMenu(void)
 {
-	IrrlichtDevice *device = createDevice( video::EDT_OPENGL,
+	IrrlichtDevice *device = createDevice( video::EDT_BURNINGSVIDEO,
 											dimension2d<u32>(160, 40), 32);
 	assert(device);
 	if (!device)

tests/lightMaps.cpp

@@ -20,6 +20,15 @@ static bool runTestWithDriver(E_DRIVER_TYPE driverType)
 	IVideoDriver* driver = device->getVideoDriver();
 	ISceneManager * smgr = device->getSceneManager();
 
+	logTestString("Testing driver %ls\n", driver->getName());
+	if (driver->getDriverAttributes().getAttributeAsInt("MaxTextures")<2)
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
 	bool result = true;
 	bool added = device->getFileSystem()->addFileArchive("../media/map-20kdm2.pk3");
 	assert(added);
@@ -55,13 +64,8 @@ static bool runTestWithDriver(E_DRIVER_TYPE driverType)
 
 bool lightMaps(void)
 {
-	bool passed = true;
-
-	passed &= runTestWithDriver(EDT_OPENGL);
-	passed &= runTestWithDriver(EDT_BURNINGSVIDEO);
-	passed &= runTestWithDriver(EDT_DIRECT3D9);
-	passed &= runTestWithDriver(EDT_DIRECT3D8);
-
-	return passed;
+	bool result = true;
+	TestWithAllDrivers(runTestWithDriver);
+	return result;
 }
 

tests/lights.cpp

@@ -10,34 +10,46 @@ static bool testLightTypes(video::E_DRIVER_TYPE driverType)
 	IrrlichtDevice *device = createDevice (driverType, core::dimension2d<u32>(128,128));
 	if (!device)
 		return true; // No error if device does not exist
-//	device->getSceneManager()->setAmbientLight(video::SColorf(0.3f,0.3f,0.3f));
-	scene::ICameraSceneNode* cam = device->getSceneManager()->addCameraSceneNode();
+
+	video::IVideoDriver* driver = device->getVideoDriver();
+	scene::ISceneManager* smgr = device->getSceneManager();
+	if (!driver->getDriverAttributes().getAttributeAsInt("MaxLights"))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+	logTestString("Testing driver %ls\n", driver->getName());
+
+//	smgr->setAmbientLight(video::SColorf(0.3f,0.3f,0.3f));
+	scene::ICameraSceneNode* cam = smgr->addCameraSceneNode();
 	cam->setPosition(core::vector3df(0,200,0));
 	cam->setTarget(core::vector3df());
-	device->getSceneManager()->addAnimatedMeshSceneNode(device->getSceneManager()->addHillPlaneMesh("plane", core::dimension2df(4,4), core::dimension2du(128,128)));
-	scene::ILightSceneNode* light1 = device->getSceneManager()->addLightSceneNode(0, core::vector3df(-100,30,-100));
+	smgr->addAnimatedMeshSceneNode(device->getSceneManager()->addHillPlaneMesh("plane", core::dimension2df(4,4), core::dimension2du(128,128)));
+	scene::ILightSceneNode* light1 = smgr->addLightSceneNode(0, core::vector3df(-100,30,-100));
 	light1->setLightType(video::ELT_POINT);
 	light1->setRadius(100.f);
 	light1->getLightData().DiffuseColor.set(0,1,1);
-//	device->getSceneManager()->addCubeSceneNode(10, light1)->setMaterialFlag(video::EMF_LIGHTING, false);
-	scene::ILightSceneNode* light2 = device->getSceneManager()->addLightSceneNode(0, core::vector3df(100,30,100));
+//	smgr->addCubeSceneNode(10, light1)->setMaterialFlag(video::EMF_LIGHTING, false);
+	scene::ILightSceneNode* light2 = smgr->addLightSceneNode(0, core::vector3df(100,30,100));
 	light2->setRotation(core::vector3df(90,0,0));
 	light2->setLightType(video::ELT_SPOT);
 	light2->setRadius(100.f);
 	light2->getLightData().DiffuseColor.set(1,0,0);
 	light2->getLightData().InnerCone=10.f;
 	light2->getLightData().OuterCone=30.f;
-//	device->getSceneManager()->addCubeSceneNode(10, light2)->setMaterialFlag(video::EMF_LIGHTING, false);
-	scene::ILightSceneNode* light3 = device->getSceneManager()->addLightSceneNode();
+//	smgr->addCubeSceneNode(10, light2)->setMaterialFlag(video::EMF_LIGHTING, false);
+	scene::ILightSceneNode* light3 = smgr->addLightSceneNode();
 	light3->setRotation(core::vector3df(15,0,0));
 	light3->setLightType(video::ELT_DIRECTIONAL);
 	light1->getLightData().DiffuseColor.set(0,1,0);
 
-	device->getVideoDriver()->beginScene (true, true, 0);
-	device->getSceneManager()->drawAll();
-	device->getVideoDriver()->endScene();
+	driver->beginScene (true, true, 0);
+	smgr->drawAll();
+	driver->endScene();
 
-	const bool result = takeScreenshotAndCompareAgainstReference(device->getVideoDriver(), "-lightType.png", 99.91f);
+	const bool result = takeScreenshotAndCompareAgainstReference(driver, "-lightType.png", 99.91f);
 
 	device->closeDevice();
 	device->run();
@@ -48,14 +60,8 @@ static bool testLightTypes(video::E_DRIVER_TYPE driverType)
 
 bool lights(void)
 {
-	bool passed = true;
-
-	passed &= testLightTypes(video::EDT_OPENGL);
+	bool result = true;
 	// no lights in sw renderer
-//	passed &= testLightTypes(video::EDT_SOFTWARE);
-	passed &= testLightTypes(video::EDT_BURNINGSVIDEO);
-	passed &= testLightTypes(video::EDT_DIRECT3D9);
-	passed &= testLightTypes(video::EDT_DIRECT3D8);
-
-	return passed;
+	TestWithAllDrivers(testLightTypes);
+	return result;
 }

tests/main.cpp

@@ -92,6 +92,8 @@ int main(int argumentCount, char * arguments[])
 	TEST(createImage);
 	TEST(cursorSetVisible);
 	TEST(flyCircleAnimator);
+	TEST(guiDisabledMenu);
+	TEST(makeColorKeyTexture);
 	TEST(md2Animation);
 	TEST(meshTransform);
 	TEST(skinnedMesh);
@@ -103,8 +105,6 @@ int main(int argumentCount, char * arguments[])
 	TEST(screenshot);
 	TEST(drawPixel);
 	TEST(drawRectOutline);
-	TEST(guiDisabledMenu);
-	TEST(makeColorKeyTexture);
 	TEST(material);
 	TEST(renderTargetTexture);
 	TEST(textureFeatures);
@@ -139,9 +139,9 @@ int main(int argumentCount, char * arguments[])
 		{
 			for (unsigned int i=0; i<tests.size(); ++i)
 			{
-				printf("%3d: %s\n", i, tests[i].testName);
+				logTestString("%3d: %s\n", i, tests[i].testName);
 			}
-			printf("\n");
+			logTestString("\n");
 			return 0;
 		}
 

tests/material.cpp

@@ -61,7 +61,7 @@ static bool polygonOffset(video::E_DRIVER_TYPE type)
 
 bool material()
 {
-	bool result = polygonOffset(video::EDT_OPENGL);
-	result &= polygonOffset(video::EDT_DIRECT3D9);
+	bool result = true;
+	TestWithAllDrivers(polygonOffset);
 	return result;
 }

tests/meshLoaders.cpp

@@ -4,24 +4,18 @@
 #include "testUtils.h"
 
 using namespace irr;
-using namespace core;
-using namespace scene;
-using namespace video;
-using namespace io;
-using namespace gui;
 
 // Tests mesh loading features and the mesh cache.
 /** This won't test render results. Currently, not all mesh loaders are tested. */
 bool meshLoaders(void)
 {
-	IrrlichtDevice *device = createDevice( EDT_NULL, dimension2d<u32>(160, 120), 32);
+	IrrlichtDevice *device = createDevice(video::EDT_NULL, core::dimension2d<u32>(160, 120), 32);
 	assert(device);
 	if (!device)
 		return false;
 
-	ISceneManager * smgr = device->getSceneManager();
-
-	IAnimatedMesh* mesh = smgr->getMesh("../media/ninja.b3d");
+	scene::ISceneManager * smgr = device->getSceneManager();
+	scene::IAnimatedMesh* mesh = smgr->getMesh("../media/ninja.b3d");
 	assert(mesh);
 
 	bool result = (mesh != 0);

tests/mrt.cpp

@@ -17,6 +17,8 @@ static bool testWithDriver(video::E_DRIVER_TYPE driverType)
 //	if (driver->getDriverAttributes().getAttributeAsInt("ShaderLanguageVersion")<=100)
 //		return true;
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	const char* const ps1="struct PS_INPUT\n {\n float4 Position      : POSITION0;\n };\n\n struct PS_OUTPUT\n {\n float4   Color      : COLOR0;\n float4   Normal      : COLOR1;\n float4   Depth      : COLOR2;\n };\n PS_OUTPUT pixelMain( PS_INPUT Input )\n {\n PS_OUTPUT Output;\n Output.Color = float4(1.0,1.0,1.0,1.0);\n Output.Normal = float4(0.0,1.0,0.0,1.0);\n Output.Depth = float4(0.0,0.0,1.0,1.0);\n return Output;\n }";
 	const char* const ps2="void main(void)\n {\n gl_FragData[0] = vec4(1.0,1.0,1.0,1.0);\n gl_FragData[1] = vec4(0.0,1.0,0.0,1.0);\n gl_FragData[2] = vec4(0.0,0.0,1.0,1.0);\n }";
 
@@ -95,10 +97,9 @@ static bool testWithDriver(video::E_DRIVER_TYPE driverType)
 
 bool mrt(void)
 {
-	bool passed = true;
+	bool result = true;
 
-	passed &= testWithDriver(video::EDT_OPENGL);
-	passed &= testWithDriver(video::EDT_DIRECT3D9);
+	TestWithAllHWDrivers(testWithDriver);
 
-	return passed;
+	return result;
 }

tests/projectionMatrix.cpp

@@ -19,6 +19,8 @@ static bool runTestWithDriver(E_DRIVER_TYPE driverType)
 
 	IVideoDriver* driver = device->getVideoDriver();
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	bool result = true;
 
 	driver->beginScene(true, false, SColor(255,0,0,0));
@@ -73,14 +75,10 @@ static bool runTestWithDriver(E_DRIVER_TYPE driverType)
 
 bool projectionMatrix(void)
 {
-	bool passed = true;
+	bool result = true;
 
 	// TODO: Seems that software driver does not handle this projection matrix
-//	passed &= runTestWithDriver(EDT_SOFTWARE);
-	passed &= runTestWithDriver(EDT_BURNINGSVIDEO);
-	passed &= runTestWithDriver(EDT_DIRECT3D9);
-	passed &= runTestWithDriver(EDT_DIRECT3D8);
-	passed &= runTestWithDriver(EDT_OPENGL);
+	TestWithAllDrivers(runTestWithDriver);
 
-	return passed;
+	return result;
 }

tests/renderTargetTexture.cpp

@@ -13,10 +13,18 @@ static bool testWith2DImage(video::E_DRIVER_TYPE driverType)
 	if (!device)
 		return true; // No error if device does not exist
 
-	device->setWindowCaption (L"Irrlicht - RTT Bug report");
 	video::IVideoDriver *driver = device->getVideoDriver ();
 	scene::ISceneManager *smgr = device->getSceneManager ();
 
+	if (!driver->queryFeature(video::EVDF_RENDER_TO_TARGET))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	video::ITexture *image = driver->getTexture ("../media/irrlichtlogo2.png");
 	video::ITexture *RTT_texture = driver->addRenderTargetTexture (core::dimension2d < u32 > (128, 128));
 
@@ -101,6 +109,8 @@ bool rttAndZBuffer(video::E_DRIVER_TYPE driverType)
 
 	IrrlichtDevice* nullDevice = createDevice(video::EDT_NULL);
 	cp.WindowSize = nullDevice->getVideoModeList()->getDesktopResolution();
+	nullDevice->closeDevice();
+	nullDevice->run();
 	nullDevice->drop();
 
 	cp.WindowSize -= core::dimension2d<u32>(100, 100);
@@ -113,7 +123,14 @@ bool rttAndZBuffer(video::E_DRIVER_TYPE driverType)
 	scene::ISceneManager* sm = device->getSceneManager();
 
 	if	(!vd->queryFeature(video::EVDF_RENDER_TO_TARGET))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
 		return true;
+	}
+
+	logTestString("Testing driver %ls\n", vd->getName());
 
 	video::ITexture* rt = vd->addRenderTargetTexture(cp.WindowSize, "rt", video::ECF_A32B32G32R32F);
 	video::S3DVertex vertices[4];
@@ -196,10 +213,24 @@ bool rttAndText(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	gui::IGUIEnvironment* guienv = device->getGUIEnvironment();
 
+	if (!driver->queryFeature(video::EVDF_RENDER_TO_TARGET))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	//RTT
 	video::ITexture* rt = driver->addRenderTargetTexture(core::dimension2d<u32>(256, 256), "rt");
 	if (!rt)
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
 		return false;
+	}
 
 	driver->beginScene(true, true, video::SColor(255,255, 255, 255));
 	driver->setRenderTarget(rt, true, true, video::SColor(255,255,0,255));
@@ -245,7 +276,8 @@ bool rttAndText(video::E_DRIVER_TYPE driverType)
 static void Render(IrrlichtDevice* device, video::ITexture* rt, core::vector3df& pos1, 
 				   core::vector3df& pos2, scene::IAnimatedMesh* sphereMesh, core::vector3df& pos3, core::vector3df& pos4)
 {
-	device->getVideoDriver()->setRenderTarget(rt);
+	video::IVideoDriver* driver = device->getVideoDriver();
+	driver->setRenderTarget(rt);
 	device->getSceneManager()->drawAll();
 
 	video::SMaterial mat;
@@ -257,27 +289,27 @@ static void Render(IrrlichtDevice* device, video::ITexture* rt, core::vector3df&
 
 	core::matrix4 m;
 	m.setTranslation(pos1);
-	device->getVideoDriver()->setTransform(video::ETS_WORLD, m);
-	device->getVideoDriver()->setMaterial(mat);
-	device->getVideoDriver()->drawMeshBuffer(sphereMesh->getMeshBuffer(0));
+	driver->setTransform(video::ETS_WORLD, m);
+	driver->setMaterial(mat);
+	driver->drawMeshBuffer(sphereMesh->getMeshBuffer(0));
 
 	m.setTranslation(pos2);
 	mat.Shininess=0.f;
-	device->getVideoDriver()->setTransform(video::ETS_WORLD, m);
-	device->getVideoDriver()->setMaterial(mat);		
-	device->getVideoDriver()->drawMeshBuffer(sphereMesh->getMeshBuffer(0));
+	driver->setTransform(video::ETS_WORLD, m);
+	driver->setMaterial(mat);		
+	driver->drawMeshBuffer(sphereMesh->getMeshBuffer(0));
 
 	m.setTranslation(pos3);
 	mat.Shininess=8.f;
-	device->getVideoDriver()->setTransform(video::ETS_WORLD, m);
-	device->getVideoDriver()->setMaterial(mat);
-	device->getVideoDriver()->drawMeshBuffer(sphereMesh->getMeshBuffer(0));
+	driver->setTransform(video::ETS_WORLD, m);
+	driver->setMaterial(mat);
+	driver->drawMeshBuffer(sphereMesh->getMeshBuffer(0));
 
 	m.setTranslation(pos4);
 	mat.Shininess=0.f;
-	device->getVideoDriver()->setTransform(video::ETS_WORLD, m);
-	device->getVideoDriver()->setMaterial(mat);
-	device->getVideoDriver()->drawMeshBuffer(sphereMesh->getMeshBuffer(0));
+	driver->setTransform(video::ETS_WORLD, m);
+	driver->setMaterial(mat);
+	driver->drawMeshBuffer(sphereMesh->getMeshBuffer(0));
 }
 
 bool rttAndAntiAliasing(video::E_DRIVER_TYPE driverType)
@@ -293,6 +325,16 @@ bool rttAndAntiAliasing(video::E_DRIVER_TYPE driverType)
 		return true;
 
 	video::IVideoDriver* driver = device->getVideoDriver();
+	if ((driver->getDriverAttributes().getAttributeAsInt("AntiAlias")<2) ||
+		(!driver->queryFeature(video::EVDF_RENDER_TO_TARGET)))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
 
 	// sphere mesh
 	scene::IAnimatedMesh* sphereMesh = device->getSceneManager()->addSphereMesh("atom", 1, 32, 32);
@@ -320,11 +362,11 @@ bool rttAndAntiAliasing(video::E_DRIVER_TYPE driverType)
 
 	video::ITexture* rt1 = device->getVideoDriver()->addRenderTargetTexture(dim_txt, "rt1", device->getColorFormat());
 	video::ITexture* rt2 = device->getVideoDriver()->addRenderTargetTexture(dim_txt, "rt2", device->getColorFormat());
-	video::ITexture* rt3 = device->getVideoDriver()->addRenderTargetTexture(dim_txt, "rt3", video::ECF_A8R8G8B8);//device->getColorFormat());
+	video::ITexture* rt3 = device->getVideoDriver()->addRenderTargetTexture(dim_txt, "rt3", video::ECF_A8R8G8B8);
 	video::ITexture* rt4 = device->getVideoDriver()->addRenderTargetTexture(dim_txt, "rt4", device->getColorFormat());
 
 	device->getSceneManager()->setActiveCamera(cam);
-	device->getVideoDriver()->beginScene(); //true, true, SColor(0, 30, 40, 60));
+	device->getVideoDriver()->beginScene();
 #if 1
 	st->setText(L"Texture Rendering");
 	Render(device, rt1, pos1, pos2, sphereMesh, pos3, pos4);
@@ -365,6 +407,8 @@ bool rttFormats(video::E_DRIVER_TYPE driverType)
 
 	video::IVideoDriver* driver = device->getVideoDriver();
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	video::ITexture* tex = 0;
 	
 	{
@@ -517,41 +561,19 @@ bool rttFormats(video::E_DRIVER_TYPE driverType)
 
 bool renderTargetTexture(void)
 {
-	bool passed = true;
+	bool result = true;
 
-	passed &= testWith2DImage(video::EDT_OPENGL);
-	passed &= testWith2DImage(video::EDT_SOFTWARE);
-	passed &= testWith2DImage(video::EDT_BURNINGSVIDEO);
-	passed &= testWith2DImage(video::EDT_DIRECT3D9);
-	passed &= testWith2DImage(video::EDT_DIRECT3D8);
+	TestWithAllDrivers(testWith2DImage);
 
 #if 0
-	passed &= rttAndZBuffer(video::EDT_OPENGL);
-	passed &= rttAndZBuffer(video::EDT_SOFTWARE);
-	passed &= rttAndZBuffer(video::EDT_BURNINGSVIDEO);
-	passed &= rttAndZBuffer(video::EDT_DIRECT3D9);
-	passed &= rttAndZBuffer(video::EDT_DIRECT3D8);
+	TestWithAllDrivers(rttAndZBuffer);
 #endif
 
-	passed &= rttAndAntiAliasing(video::EDT_OPENGL);
-//	passed &= rttAndAntiAliasing(video::EDT_SOFTWARE);
-	passed &= rttAndAntiAliasing(video::EDT_BURNINGSVIDEO);
-	passed &= rttAndAntiAliasing(video::EDT_DIRECT3D9);
-	passed &= rttAndAntiAliasing(video::EDT_DIRECT3D8);
-
-	passed &= rttAndText(video::EDT_OPENGL);
-	passed &= rttAndText(video::EDT_DIRECT3D9);
-	passed &= rttAndText(video::EDT_DIRECT3D8);
-	passed &= rttAndText(video::EDT_BURNINGSVIDEO);
-	passed &= rttAndText(video::EDT_SOFTWARE);
+	TestWithAllDrivers(rttAndAntiAliasing);
+	TestWithAllDrivers(rttAndText);
 
 	logTestString("Test RTT format support\n");
-	logTestString("OpenGL:\n");
-	passed &= rttFormats(video::EDT_OPENGL);
-	logTestString("D3D9:\n");
-	passed &= rttFormats(video::EDT_DIRECT3D9);
-	logTestString("D3D8:\n");
-	passed &= rttFormats(video::EDT_DIRECT3D8);
-
-	return passed;
+	TestWithAllHWDrivers(rttFormats);
+
+	return result;
 }

tests/sceneCollisionManager.cpp

@@ -456,7 +456,7 @@ static bool compareGetSceneNodeFromRayBBWithBBIntersectsWithLine(IrrlichtDevice
 /** Test functionality of the sceneCollisionManager */
 bool sceneCollisionManager(void)
 {
-	IrrlichtDevice * device = irr::createDevice(video::EDT_OPENGL, dimension2d<u32>(160, 120));
+	IrrlichtDevice * device = irr::createDevice(video::EDT_NULL, dimension2d<u32>(160, 120));
 	assert(device);
 	if(!device)
 		return false;

tests/screenshot.cpp

@@ -15,6 +15,8 @@ bool testShots(video::E_DRIVER_TYPE type)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager * smgr = device->getSceneManager();
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	scene::IAnimatedMesh* mesh = smgr->getMesh("../media/sydney.md2");
 	scene::IAnimatedMeshSceneNode* node;
 
@@ -55,7 +57,7 @@ bool testShots(video::E_DRIVER_TYPE type)
 
 bool screenshot()
 {
-	testShots(video::EDT_OPENGL);
-	testShots(video::EDT_DIRECT3D9);
-	return true;
+	bool result = true;
+	TestWithAllHWDrivers(testShots);
+	return result;
 }

tests/terrainSceneNode.cpp

@@ -11,7 +11,7 @@ namespace
 bool terrainRecalc(void)
 {
     IrrlichtDevice *device =
-        createDevice(video::EDT_OPENGL, dimension2du(160, 120), 32);
+        createDevice(video::EDT_BURNINGSVIDEO, dimension2du(160, 120), 32);
 
 	if (!device)
 		return true;
@@ -77,7 +77,7 @@ bool terrainRecalc(void)
 
 bool terrainGaps()
 {
-	IrrlichtDevice* device = createDevice(video::EDT_OPENGL, dimension2d<u32>(160, 120));
+	IrrlichtDevice* device = createDevice(video::EDT_BURNINGSVIDEO, dimension2d<u32>(160, 120));
 	if (!device)
 		return true;
 

tests/testUtils.h

@@ -5,6 +5,13 @@
 #include "irrlicht.h"
 #include <assert.h>
 
+#define TestWithAllDrivers(X, ...) \
+	for (u32 i=1; i<video::EDT_COUNT; ++i) \
+		result &= X(video::E_DRIVER_TYPE(i), __VA_ARGS__)
+#define TestWithAllHWDrivers(X, ...) \
+	for (u32 i=video::EDT_DIRECT3D8; i<video::EDT_COUNT; ++i) \
+		result &= X(video::E_DRIVER_TYPE(i), __VA_ARGS__)
+
 //! Compare two files
 /** \param fileName1 The first file for comparison.
 	\param fileName1 The second file for comparison.

tests/textureFeatures.cpp

@@ -17,6 +17,15 @@ bool renderMipLevels(video::E_DRIVER_TYPE driverType)
 
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager * smgr = device->getSceneManager();
+	if (!driver->queryFeature(video::EVDF_MIP_MAP))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
 
 	scene::ISceneNode* n = smgr->addCubeSceneNode();
 	scene::ISceneNode* n2 = smgr->addCubeSceneNode(10, 0, -1, core::vector3df(20,0,30), core::vector3df(0,45,0));
@@ -87,6 +96,16 @@ bool lockAllMipLevels(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager * smgr = device->getSceneManager();
 
+	if (!driver->queryFeature(video::EVDF_MIP_MAP))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	scene::ISceneNode* n = smgr->addCubeSceneNode();
 
 	if (n)
@@ -193,6 +212,16 @@ bool lockWithAutoMipmap(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager * smgr = device->getSceneManager();
 
+	if (!driver->queryFeature(video::EVDF_MIP_MAP))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	scene::ISceneNode* n = smgr->addCubeSceneNode();
 
 	if (n)
@@ -263,24 +292,11 @@ bool lockWithAutoMipmap(video::E_DRIVER_TYPE driverType)
 
 bool textureFeatures(void)
 {
-	bool passed = true;
-
-	logTestString("OpenGL\n");
-	passed &= renderMipLevels(video::EDT_OPENGL);
-	passed &= lockAllMipLevels(video::EDT_OPENGL);
-	passed &= lockWithAutoMipmap(video::EDT_OPENGL);
-	logTestString("Burnings Video\n");
-	passed &= renderMipLevels(video::EDT_BURNINGSVIDEO);
-	passed &= lockAllMipLevels(video::EDT_BURNINGSVIDEO);
-	passed &= lockWithAutoMipmap(video::EDT_BURNINGSVIDEO);
-	logTestString("Direct3D9\n");
-	passed &= renderMipLevels(video::EDT_DIRECT3D9);
-	passed &= lockAllMipLevels(video::EDT_DIRECT3D9);
-	passed &= lockWithAutoMipmap(video::EDT_DIRECT3D9);
-	logTestString("Direct3D8\n");
-	passed &= renderMipLevels(video::EDT_DIRECT3D8);
-	passed &= lockAllMipLevels(video::EDT_DIRECT3D8);
-	passed &= lockWithAutoMipmap(video::EDT_DIRECT3D8);
-
-	return passed;
+	bool result = true;
+
+	TestWithAllDrivers(renderMipLevels);
+	TestWithAllDrivers(lockAllMipLevels);
+	TestWithAllDrivers(lockWithAutoMipmap);
+
+	return result;
 }

tests/textureRenderStates.cpp

@@ -14,6 +14,9 @@ static bool manyTextures(video::E_DRIVER_TYPE driverType)
 
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager * smgr = device->getSceneManager();
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	(void)smgr->addCameraSceneNode();
 
 	scene::SMeshBufferLightMap* mesh = new scene::SMeshBufferLightMap;
@@ -73,6 +76,8 @@ static bool renderAndLoad(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager * smgr = device->getSceneManager();
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	video::ITexture* tex1 = driver->getTexture("../media/wall.bmp");
 
 	(void)smgr->addCameraSceneNode();
@@ -108,6 +113,8 @@ static bool renderAndRemove(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager * smgr = device->getSceneManager();
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	driver->beginScene (true, true, video::SColor(255, 0, 255, 0));
 	smgr->drawAll();
 	driver->endScene();
@@ -155,6 +162,16 @@ static bool testTextureMatrixInMixedScenes(video::E_DRIVER_TYPE driverType)
 	scene::ISceneManager* sceneManager = device->getSceneManager();
 	gui::IGUIEnvironment* gui = device->getGUIEnvironment();
 
+	if (!driver->queryFeature(video::EVDF_TEXTURE_MATRIX))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	scene::ICameraSceneNode* camera = sceneManager->addCameraSceneNode();
 	camera->setPosition(vector3df(0,10,0));
 
@@ -200,6 +217,16 @@ static bool textureMatrix(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager* sceneManager = device->getSceneManager();
 
+	if (!driver->queryFeature(video::EVDF_TEXTURE_MATRIX))
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	scene::ICameraSceneNode* camera = sceneManager->addCameraSceneNode();
 	camera->setPosition(vector3df(0,0,-10));
 
@@ -248,35 +275,13 @@ static bool textureMatrix(video::E_DRIVER_TYPE driverType)
 
 bool textureRenderStates(void)
 {
-	bool passed = true;
-
-	passed &= renderAndLoad(video::EDT_OPENGL);
-	passed &= renderAndLoad(video::EDT_SOFTWARE);
-	passed &= renderAndLoad(video::EDT_BURNINGSVIDEO);
-	passed &= renderAndLoad(video::EDT_DIRECT3D9);
-	passed &= renderAndLoad(video::EDT_DIRECT3D8);
-
-	passed &= renderAndRemove(video::EDT_OPENGL);
-	passed &= renderAndRemove(video::EDT_SOFTWARE);
-	passed &= renderAndRemove(video::EDT_BURNINGSVIDEO);
-	passed &= renderAndRemove(video::EDT_DIRECT3D9);
-	passed &= renderAndRemove(video::EDT_DIRECT3D8);
-
-	passed &= testTextureMatrixInMixedScenes(video::EDT_OPENGL);
-	passed &= testTextureMatrixInMixedScenes(video::EDT_SOFTWARE);
-	passed &= testTextureMatrixInMixedScenes(video::EDT_BURNINGSVIDEO);
-	passed &= testTextureMatrixInMixedScenes(video::EDT_DIRECT3D9);
-	passed &= testTextureMatrixInMixedScenes(video::EDT_DIRECT3D8);
-
-	passed &= manyTextures(video::EDT_OPENGL);
-	passed &= manyTextures(video::EDT_SOFTWARE);
-	passed &= manyTextures(video::EDT_BURNINGSVIDEO);
-	passed &= manyTextures(video::EDT_DIRECT3D9);
-	passed &= manyTextures(video::EDT_DIRECT3D8);
-
-	passed &= textureMatrix(video::EDT_OPENGL);
-	passed &= textureMatrix(video::EDT_DIRECT3D9);
-
-	return passed;
-}
+	bool result = true;
+
+	TestWithAllDrivers(renderAndLoad);
+	TestWithAllDrivers(renderAndRemove);
+	TestWithAllDrivers(testTextureMatrixInMixedScenes);
+	TestWithAllDrivers(manyTextures);
+	TestWithAllDrivers(textureMatrix);
 
+	return result;
+}

tests/transparentMaterials.cpp

@@ -19,6 +19,16 @@ bool testTransparentAlphaChannelRef(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager* smgr = device->getSceneManager();
 
+	if (driver->getColorFormat() != video::ECF_A8R8G8B8)
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);
 
 	ISceneNode * backCube = smgr->addCubeSceneNode();
@@ -59,6 +69,16 @@ bool testTransparentAlphaChannel(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager* smgr = device->getSceneManager();
 
+	if (driver->getColorFormat() != video::ECF_A8R8G8B8)
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);
 
 	ISceneNode * backCube = smgr->addCubeSceneNode();
@@ -99,6 +119,16 @@ bool testTransparentVertexAlpha(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager* smgr = device->getSceneManager();
 
+	if (driver->getColorFormat() != video::ECF_A8R8G8B8)
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);
 
 	ISceneNode * backCube = smgr->addCubeSceneNode();
@@ -146,6 +176,16 @@ bool testTransparentReflection2Layer(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager* smgr = device->getSceneManager();
 
+	if (driver->getColorFormat() != video::ECF_A8R8G8B8)
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);
 
 	ISceneNode * backCube = smgr->addCubeSceneNode();
@@ -196,6 +236,16 @@ bool testTransparentAddColor(video::E_DRIVER_TYPE driverType)
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager* smgr = device->getSceneManager();
 
+	if (driver->getColorFormat() != video::ECF_A8R8G8B8)
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);
 
 	ISceneNode * backCube = smgr->addCubeSceneNode();
@@ -235,6 +285,16 @@ bool testTransparentVertexAlphaMore(E_DRIVER_TYPE driverType)
 	IVideoDriver* driver = device->getVideoDriver();
 	ISceneManager* smgr = device->getSceneManager();
 
+	if (driver->getColorFormat() != video::ECF_A8R8G8B8)
+	{
+		device->closeDevice();
+		device->run();
+		device->drop();
+		return true;
+	}
+
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	IAnimatedMesh* mesh = smgr->getMesh("../media/sydney.md2");
 	IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
 	IMeshSceneNode* cube = smgr->addCubeSceneNode(10.0f,0,-1,vector3df(-5,3,-15));
@@ -279,37 +339,21 @@ bool testTransparentVertexAlphaMore(E_DRIVER_TYPE driverType)
 
 bool transparentMaterials(void)
 {
-	bool result = testTransparentAlphaChannel(EDT_DIRECT3D9);
-	result &= testTransparentAlphaChannel(EDT_OPENGL);
-	result &= testTransparentAlphaChannel(EDT_BURNINGSVIDEO);
-
-	result &= testTransparentAlphaChannelRef(EDT_DIRECT3D9);
-	result &= testTransparentAlphaChannelRef(EDT_OPENGL);
+	bool result = true;
+	TestWithAllDrivers(testTransparentAlphaChannel);
 	// FIXME Rogerborg 8-January-2011. Burning's video currently produces unexpected results,
 	// blending using the full alpha value instead of using a boolean mask. This test is being
 	// added now anyway to help verify the fix when it's done; it should just require an
 	// update of the reference image.
-	result &= testTransparentAlphaChannelRef(EDT_BURNINGSVIDEO);
-
-	result &= testTransparentVertexAlpha(EDT_DIRECT3D9);
-	result &= testTransparentVertexAlpha(EDT_OPENGL);
+	TestWithAllDrivers(testTransparentAlphaChannelRef);
 	// This type seems to be broken as well for Burning's video.
-	result &= testTransparentVertexAlpha(EDT_BURNINGSVIDEO);
-
-	result &= testTransparentAddColor(EDT_DIRECT3D9);
-	result &= testTransparentAddColor(EDT_OPENGL);
-	result &= testTransparentAddColor(EDT_BURNINGSVIDEO);
-
+	TestWithAllDrivers(testTransparentVertexAlpha);
+	TestWithAllDrivers(testTransparentAddColor);
 	// TODO: this simply does not work in OpenGL due to the sphere map
 	// at least it creates different results, and also varies across drivers
-//	result &= testTransparentReflection2Layer(EDT_OPENGL);
-	result &= testTransparentReflection2Layer(EDT_DIRECT3D9);
-	result &= testTransparentReflection2Layer(EDT_BURNINGSVIDEO);
-
-	result &= testTransparentVertexAlphaMore(EDT_DIRECT3D9);
-	result &= testTransparentVertexAlphaMore(EDT_OPENGL);
+	TestWithAllDrivers(testTransparentReflection2Layer);
 	// This type seems to be broken as well for Burning's video.
-	result &= testTransparentVertexAlphaMore(EDT_BURNINGSVIDEO);
+	TestWithAllDrivers(testTransparentVertexAlphaMore);
 
 	return result;
 }

tests/videoDriver.cpp

@@ -28,7 +28,7 @@ bool testVideoDriver(video::E_DRIVER_TYPE driverType)
 	logTestString("MaxTextureSize: %d\n", driver->getDriverAttributes().getAttributeAsInt("MaxTextureSize"));
 	logTestString("MaxGeometryVerticesOut: %d\n", driver->getDriverAttributes().getAttributeAsInt("MaxGeometryVerticesOut"));
 	logTestString("Version: %d\n", driver->getDriverAttributes().getAttributeAsInt("Version"));
-	logTestString("ShaderLanguageVersion: %d\n", driver->getDriverAttributes().getAttributeAsInt("ShaderLanguageVersion"));
+	logTestString("ShaderLanguageVersion: %d\n\n", driver->getDriverAttributes().getAttributeAsInt("ShaderLanguageVersion"));
 
 	device->closeDevice();
 	device->run();
@@ -38,11 +38,7 @@ bool testVideoDriver(video::E_DRIVER_TYPE driverType)
 
 bool videoDriver()
 {
-	bool result = testVideoDriver(video::EDT_OPENGL);
-	result &= testVideoDriver(video::EDT_DIRECT3D9);
-	result &= testVideoDriver(video::EDT_DIRECT3D8);
-	result &= testVideoDriver(video::EDT_BURNINGSVIDEO);
-	result &= testVideoDriver(video::EDT_SOFTWARE);
-	result &= testVideoDriver(video::EDT_NULL);
+	bool result = true;
+	TestWithAllDrivers(testVideoDriver);
 	return result;
 }

tests/viewPort.cpp

@@ -29,6 +29,8 @@ static bool viewPortText(E_DRIVER_TYPE driverType)
 	IGUIEnvironment* env = smgr->getGUIEnvironment();
 	env->addCheckBox(true, core::recti(10,60,28,82));
 
+	logTestString("Testing driver %ls\n", driver->getName());
+
 	IBillboardSceneNode * bnode = smgr->addBillboardSceneNode(0,dimension2d<f32>(32,32),core::vector3df(0,0,10));
 	bnode->setMaterialFlag(video::EMF_LIGHTING, false);
 	bnode->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
@@ -63,21 +65,12 @@ static bool viewPortText(E_DRIVER_TYPE driverType)
 
 bool viewPort(void)
 {
-	bool passed = true;
+	bool result = true;
 
-	logTestString("Check OpenGL driver\n");
-	passed &= viewPortText(EDT_OPENGL);
 	// TODO: software driver and burnings don't use view port for
 	// 2d rendering, so result is pretty wrong.
-	logTestString("Check Software driver\n");
-	passed &= viewPortText(EDT_SOFTWARE);
-	logTestString("Check Burning's Video driver\n");
-	passed &= viewPortText(EDT_BURNINGSVIDEO);
-	logTestString("Check Direct3D9 driver\n");
-	passed &= viewPortText(EDT_DIRECT3D9);
-	logTestString("Check Direct3D8 driver\n");
-	passed &= viewPortText(EDT_DIRECT3D8);
-
-	return passed;
+	TestWithAllDrivers(viewPortText);
+
+	return result;
 }
 

tests/writeImageToFile.cpp

@@ -53,8 +53,8 @@ bool writeImageToFile(void)
 	const char * referenceFilename = 0;
 	video::ECOLOR_FORMAT format;
 
-	irr::video::IImage * screenshot = driver->createScreenShot();
-	if(!screenshot)
+	irr::video::IImage * screenshot = driver->createScreenShot(video::ECF_R8G8B8);
+	if (!screenshot)
 	{
 		logTestString("Failed to take screenshot\n");
 		assert(false);
@@ -62,14 +62,14 @@ bool writeImageToFile(void)
 	}
 
 	format = screenshot->getColorFormat();
-	if(format != video::ECF_R8G8B8)
+	if (format != video::ECF_R8G8B8)
 	{
 		irr::video::IImage * fixedScreenshot = driver->createImage(video::ECF_R8G8B8, screenshot->getDimension());
 		screenshot->copyTo(fixedScreenshot);
 		screenshot->drop();
 		screenshot = 0;
 
-		if(!fixedScreenshot)
+		if (!fixedScreenshot)
 		{
 			logTestString("Failed to convert screenshot to ECF_A8R8G8B8\n");
 			assert(false);
@@ -82,7 +82,7 @@ bool writeImageToFile(void)
 	buffer = new c8[BUFFER_SIZE];
 	writtenFilename = "results/Burning's Video-writeImageToFile.png";
 	memoryFile = device->getFileSystem()->createMemoryWriteFile(buffer, BUFFER_SIZE, writtenFilename, false);
-	if(!driver->writeImageToFile(screenshot, memoryFile))
+	if (!driver->writeImageToFile(screenshot, memoryFile))
 	{
 		logTestString("Failed to write png to memory file\n");
 		assert(false);
@@ -90,14 +90,14 @@ bool writeImageToFile(void)
 	}
 
 	writtenFile = device->getFileSystem()->createAndWriteFile(memoryFile->getFileName());
-	if(!writtenFile)
+	if (!writtenFile)
 	{
 		logTestString("Can't open %s for writing.\n", writtenFilename);
 		assert(false);
 		goto cleanup;
 	}
 
-	if(memoryFile->getPos() != writtenFile->write(buffer, memoryFile->getPos()))
+	if (memoryFile->getPos() != writtenFile->write(buffer, memoryFile->getPos()))
 	{
 		logTestString("Error while writing to %s.\n", writtenFilename);
 		assert(false);
@@ -108,7 +108,7 @@ bool writeImageToFile(void)
 	writtenFile = 0;
 
 	referenceFilename = "media/Burning's Video-drawPixel.png";
-	if(!binaryCompareFiles(writtenFilename, referenceFilename))
+	if (!binaryCompareFiles(writtenFilename, referenceFilename))
 	{
 		logTestString("File written from memory is not the same as the reference file. %s:%d\n" ,  __FILE__, __LINE__);
 //		assert(false);