TestMain Class Reference

#include <testmain.h>

Public Member Functions
	TestMain ()
	~TestMain ()
int	exec (const bool testAudio=true)
Configuration &	getConfig ()

Static Public Member Functions
static int	readValue (const int ver, int def)

Private Member Functions
void	initConfig ()
int	invokeTest (const std::string &test)
int	invokeTest3 ()
int	invokeTest4 ()
int	invokeTest7 ()
int	invokeSoftwareRenderTest (const std::string &test)
int	invokeNormalOpenGLRenderTest (const std::string &test)
int	invokeNormalOpenBatchTest (const std::string &test)
int	invokeModernOpenGLRenderTest (const std::string &test)
int	invokeModernOpenBatchTest (const std::string &test)
int	invokeMobileOpenBatchTest (const std::string &test)
int	invokeSafeOpenBatchTest (const std::string &test)
int	invokeSafeOpenGLRenderTest (const std::string &test)
void	testsMain ()
void	writeConfig (const RenderType openGLMode, const int rescale, const int sound, const std::string &info, const int batchSize, const std::string &textureSize, const int detectMode)
int	readValue2 (const int ver)

Private Attributes
Logger *	log
Configuration	mConfig

Detailed Description

Definition at line 33 of file testmain.h.

Constructor & Destructor Documentation

TestMain()

TestMain::TestMain

(

)

Definition at line 42 of file testmain.cpp.

                   :
    log(new Logger),
    mConfig()
{
    fileName = getSelfName();
    log->setLogFile(pathJoin(settings.localDataDir, "manaplustest.log"));
}

References fileName, getSelfName(), Settings::localDataDir, log, pathJoin(), Logger::setLogFile(), and settings.

~TestMain()

TestMain::~TestMain

(

)

Definition at line 50 of file testmain.cpp.

{
    delete2(log)
}

References delete2, and log.

Member Function Documentation

exec()

int TestMain::exec

(

const bool

testAudio = true

)

Definition at line 78 of file testmain.cpp.

{
    initConfig();
    int softwareTest = invokeSoftwareRenderTest("1");
    int soundTest = -1;
    int rescaleTest[6];
    int softFps = 0;
    int normalOpenGLFps = 0;
    int safeOpenGLFps = 0;
    int modernOpenGLFps = 0;
    int textureSize[6];
    std::string textureSizeStr;
 
    RenderType openGLMode = RENDER_SOFTWARE;
    int detectMode = 0;
    for (int f = 0; f < 6; f ++)
    {
        rescaleTest[f] = -1;
        textureSize[f] = 1024;
    }
    std::string info;
 
    const int videoDetectTest = invokeTest("99");
    if (videoDetectTest == 0)
        detectMode = readValue2(99);
 
    int normalOpenGLTest = invokeNormalOpenGLRenderTest("2");
    int safeOpenGLTest = invokeSafeOpenGLRenderTest("3");
    int modernOpenGLTest = invokeModernOpenGLRenderTest("19");
    if (testAudio)
        soundTest = invokeTest4();
    else
        soundTest = 0;
 
    info.append(strprintf("%d.%d,%d,%d,%d.", soundTest, softwareTest,
        normalOpenGLTest, safeOpenGLTest, modernOpenGLTest));
 
    if (softwareTest == 0)
    {
        int softFpsTest = invokeSoftwareRenderTest("8");
        info.append(strprintf("%d", softFpsTest));
        if (softFpsTest == 0)
        {
            softFps = readValue2(8);
            info.append(strprintf(",%d", softFps));
            if (softFps == 0)
            {
                softwareTest = -1;
                softFpsTest = -1;
            }
            else
            {
                rescaleTest[0] = invokeSoftwareRenderTest("5");
                info.append(strprintf(",%d", rescaleTest[0]));
            }
        }
        else
        {
            softwareTest = -1;
        }
    }
    info.append(".");
    if (modernOpenGLTest == 0)
    {
        int modernOpenGLFpsTest = invokeModernOpenGLRenderTest("17");
        info.append(strprintf("%d", modernOpenGLFpsTest));
        if (modernOpenGLFpsTest == 0)
        {
            modernOpenGLFps = readValue2(17);
            info.append(strprintf(",%d", modernOpenGLFps));
            if (modernOpenGLFps == 0)
            {
                modernOpenGLTest = -1;
                modernOpenGLFpsTest = -1;
            }
            else
            {
                rescaleTest[3] = invokeModernOpenGLRenderTest("18");
                info.append(strprintf(",%d", rescaleTest[3]));
            }
        }
        else
        {
            modernOpenGLTest = -1;
        }
    }
    info.append(".");
    if (normalOpenGLTest == 0)
    {
        int normalOpenGLFpsTest = invokeNormalOpenGLRenderTest("9");
        info.append(strprintf("%d", normalOpenGLFpsTest));
        if (normalOpenGLFpsTest == 0)
        {
            normalOpenGLFps = readValue2(9);
            info.append(strprintf(",%d", normalOpenGLFps));
            if (normalOpenGLFps == 0)
            {
                normalOpenGLTest = -1;
                normalOpenGLFpsTest = -1;
            }
            else
            {
                rescaleTest[1] = invokeNormalOpenGLRenderTest("6");
                info.append(strprintf(",%d", rescaleTest[1]));
            }
        }
        else
        {
            normalOpenGLTest = -1;
        }
    }
    info.append(".");
    if (safeOpenGLTest == 0)
    {
        int safeOpenGLFpsTest = invokeSafeOpenGLRenderTest("10");
        info.append(strprintf("%d", safeOpenGLFpsTest));
        if (safeOpenGLFpsTest == 0)
        {
            safeOpenGLFps = readValue2(10);
            info.append(strprintf(",%d", safeOpenGLFps));
            if (safeOpenGLFps == 0)
            {
                safeOpenGLTest = -1;
                safeOpenGLFpsTest = -1;
            }
            else
            {
                rescaleTest[2] = invokeSafeOpenGLRenderTest("7");
                info.append(strprintf(",%d", rescaleTest[2]));
            }
        }
        else
        {
            safeOpenGLTest = -1;
        }
    }
    info.append(".");
 
    int maxFps = softFps;
    if (maxFps < normalOpenGLFps)
    {
        openGLMode = RENDER_NORMAL_OPENGL;
        maxFps = normalOpenGLFps;
    }
    if (maxFps < modernOpenGLFps)
    {
        openGLMode = RENDER_MODERN_OPENGL;
        maxFps = modernOpenGLFps;
    }
    if (maxFps < safeOpenGLFps)
    {
        openGLMode = RENDER_SAFE_OPENGL;
        maxFps = safeOpenGLFps;
    }
 
    int batchSize = 256;
 
    if (invokeNormalOpenBatchTest("11") == 0)
        batchSize = readValue2(11);
    if (batchSize < 256)
        batchSize = 256;
 
    if (invokeNormalOpenBatchTest("14") == 0)
    {
        textureSize[CAST_SIZE(RENDER_NORMAL_OPENGL)]
            = readValue2(14);
    }
    if (invokeModernOpenBatchTest("15") == 0)
    {
        textureSize[CAST_SIZE(RENDER_MODERN_OPENGL)]
            = readValue2(15);
    }
    if (invokeSafeOpenBatchTest("16") == 0)
    {
        textureSize[CAST_SIZE(RENDER_SAFE_OPENGL)]
            = readValue2(16);
    }
    if (invokeMobileOpenBatchTest("20") == 0)
    {
        textureSize[CAST_SIZE(RENDER_GLES_OPENGL)]
            = readValue2(20);
    }
    for (int f = 0; f < 6; f ++)
        info.append(strprintf(",%d", textureSize[f]));
    info.append(",-");
 
    textureSizeStr = toString(textureSize[0]);
    for (int f = 1; f < 6; f ++)
        textureSizeStr.append(strprintf(",%d", textureSize[f]));
 
    // if OpenGL implimentation is not good, disable it.
    if ((detectMode & 15) == 0)
        openGLMode = RENDER_SOFTWARE;
 
    writeConfig(openGLMode, rescaleTest[CAST_SIZE(openGLMode)],
        soundTest, info, batchSize, textureSizeStr, detectMode);
    return 0;
}

References CAST_SIZE, Actions::info(), initConfig(), invokeMobileOpenBatchTest(), invokeModernOpenBatchTest(), invokeModernOpenGLRenderTest(), invokeNormalOpenBatchTest(), invokeNormalOpenGLRenderTest(), invokeSafeOpenBatchTest(), invokeSafeOpenGLRenderTest(), invokeSoftwareRenderTest(), invokeTest(), invokeTest4(), openGLMode, readValue2(), RENDER_GLES_OPENGL, RENDER_MODERN_OPENGL, RENDER_NORMAL_OPENGL, RENDER_SAFE_OPENGL, RENDER_SOFTWARE, strprintf(), Catch::toString(), and writeConfig().

Referenced by GraphicsManager::startDetection().

getConfig()

Configuration& TestMain::getConfig ( )

inline

Definition at line 46 of file testmain.h.

        { return mConfig; }

References mConfig.

Referenced by Setup_Video::action(), and GraphicsManager::detectVideoSettings().

initConfig()

void TestMain::initConfig ( )

private

Definition at line 55 of file testmain.cpp.

{
    mConfig.init(settings.configDir + "/test.xml",
        UseVirtFs_false,
        SkipError_false);
    mConfig.clear();
//    setConfigDefaults(mConfig);
 
    mConfig.setValue("hwaccel", false);
    mConfig.setValue("screen", false);
    mConfig.setValue("sound", false);
    mConfig.setValue("guialpha", 0.8F);
//    mConfig.setValue("remember", true);
    mConfig.setValue("sfxVolume", 50);
    mConfig.setValue("musicVolume", 60);
    mConfig.setValue("fpslimit", 0);
    mConfig.setValue("customcursor", true);
    mConfig.setValue("useScreenshotDirectorySuffix", true);
    mConfig.setValue("ChatLogLength", 128);
    mConfig.setValue("screenwidth", 800);
    mConfig.setValue("screenheight", 600);
}

References ConfigurationObject::clear(), Settings::configDir, Configuration::init(), mConfig, settings, Configuration::setValue(), SkipError_false, and UseVirtFs_false.

Referenced by exec().

invokeMobileOpenBatchTest()

int TestMain::invokeMobileOpenBatchTest ( const std::string &  test )

private

Definition at line 412 of file testmain.cpp.

{
    mConfig.setValue("opengl", CAST_S32(RENDER_GLES_OPENGL));
    mConfig.write();
    const int ret = execFileWait(fileName, fileName, "-t", test, 30);
//    log->log("%s: %d", test.c_str(), ret);
    return ret;
}

References CAST_S32, execFileWait(), fileName, mConfig, RENDER_GLES_OPENGL, Configuration::setValue(), and Configuration::write().

Referenced by exec().

invokeModernOpenBatchTest()

int TestMain::invokeModernOpenBatchTest ( const std::string &  test )

private

Definition at line 403 of file testmain.cpp.

{
    mConfig.setValue("opengl", CAST_S32(RENDER_MODERN_OPENGL));
    mConfig.write();
    const int ret = execFileWait(fileName, fileName, "-t", test, 30);
//    log->log("%s: %d", test.c_str(), ret);
    return ret;
}

References CAST_S32, execFileWait(), fileName, mConfig, RENDER_MODERN_OPENGL, Configuration::setValue(), and Configuration::write().

Referenced by exec().

invokeModernOpenGLRenderTest()

int TestMain::invokeModernOpenGLRenderTest ( const std::string &  test )

private

Definition at line 385 of file testmain.cpp.

{
    mConfig.setValue("opengl", CAST_S32(RENDER_MODERN_OPENGL));
    mConfig.write();
    const int ret = execFileWait(fileName, fileName, "-t", test, 30);
    log->log("%s: %d", test.c_str(), ret);
    return ret;
}

References CAST_S32, execFileWait(), fileName, Logger::log(), log, mConfig, RENDER_MODERN_OPENGL, Configuration::setValue(), and Configuration::write().

Referenced by exec().

invokeNormalOpenBatchTest()

int TestMain::invokeNormalOpenBatchTest ( const std::string &  test )

private

Definition at line 394 of file testmain.cpp.

{
    mConfig.setValue("opengl", CAST_S32(RENDER_NORMAL_OPENGL));
    mConfig.write();
    const int ret = execFileWait(fileName, fileName, "-t", test, 30);
//    log->log("%s: %d", test.c_str(), ret);
    return ret;
}

References CAST_S32, execFileWait(), fileName, mConfig, RENDER_NORMAL_OPENGL, Configuration::setValue(), and Configuration::write().

Referenced by exec().

invokeNormalOpenGLRenderTest()

int TestMain::invokeNormalOpenGLRenderTest ( const std::string &  test )

private

Definition at line 376 of file testmain.cpp.

{
    mConfig.setValue("opengl", CAST_S32(RENDER_NORMAL_OPENGL));
    mConfig.write();
    const int ret = execFileWait(fileName, fileName, "-t", test, 30);
    log->log("%s: %d", test.c_str(), ret);
    return ret;
}

References CAST_S32, execFileWait(), fileName, Logger::log(), log, mConfig, RENDER_NORMAL_OPENGL, Configuration::setValue(), and Configuration::write().

Referenced by exec().

invokeSafeOpenBatchTest()

int TestMain::invokeSafeOpenBatchTest ( const std::string &  test )

private

Definition at line 421 of file testmain.cpp.

{
    mConfig.setValue("opengl", CAST_S32(RENDER_SAFE_OPENGL));
    mConfig.write();
    const int ret = execFileWait(fileName, fileName, "-t", test, 30);
//    log->log("%s: %d", test.c_str(), ret);
    return ret;
}

References CAST_S32, execFileWait(), fileName, mConfig, RENDER_SAFE_OPENGL, Configuration::setValue(), and Configuration::write().

Referenced by exec().

invokeSafeOpenGLRenderTest()

int TestMain::invokeSafeOpenGLRenderTest ( const std::string &  test )

private

Definition at line 430 of file testmain.cpp.

{
    mConfig.setValue("opengl", CAST_S32(RENDER_SAFE_OPENGL));
    mConfig.write();
    const int ret = execFileWait(fileName, fileName, "-t", test, 30);
    log->log("%s: %d", test.c_str(), ret);
    return ret;
}

References CAST_S32, execFileWait(), fileName, Logger::log(), log, mConfig, RENDER_SAFE_OPENGL, Configuration::setValue(), and Configuration::write().

Referenced by exec().

invokeSoftwareRenderTest()

int TestMain::invokeSoftwareRenderTest ( const std::string &  test )

private

Definition at line 367 of file testmain.cpp.

{
    mConfig.setValue("opengl", CAST_S32(RENDER_SOFTWARE));
    mConfig.write();
    const int ret = execFileWait(fileName, fileName, "-t", test, 30);
    log->log("%s: %d", test.c_str(), ret);
    return ret;
}

References CAST_S32, execFileWait(), fileName, Logger::log(), log, mConfig, RENDER_SOFTWARE, Configuration::setValue(), and Configuration::write().

Referenced by exec().

invokeTest()

int TestMain::invokeTest ( const std::string &  test )

private

Definition at line 349 of file testmain.cpp.

{
    mConfig.setValue("opengl", CAST_S32(RENDER_SOFTWARE));
 
    mConfig.write();
    const int ret = execFileWait(fileName, fileName, "-t", test, 0);
    return ret;
}

References CAST_S32, execFileWait(), fileName, mConfig, RENDER_SOFTWARE, Configuration::setValue(), and Configuration::write().

Referenced by exec(), and invokeTest4().

invokeTest3()

int TestMain::invokeTest3 ( )

private

invokeTest4()

int TestMain::invokeTest4 ( )

private

Definition at line 358 of file testmain.cpp.

{
    mConfig.setValue("sound", true);
    const int ret = invokeTest("4");
 
    log->log("4: %d", ret);
    return ret;
}

References invokeTest(), Logger::log(), log, mConfig, and Configuration::setValue().

Referenced by exec().

invokeTest7()

int TestMain::invokeTest7 ( )

private

readValue()

int TestMain::readValue ( const int  ver, int  def  )

static

Definition at line 326 of file testmain.cpp.

{
    std::string tmp;
    int var;
    std::ifstream file;
    file.open(pathJoin(settings.localDataDir, "test.log").c_str(),
        std::ios::in);
    if (!getline(file, tmp))
    {
        file.close();
        return def;
    }
    var = atoi(tmp.c_str());
    if (ver != var || !getline(file, tmp))
    {
        file.close();
        return def;
    }
    def = atoi(tmp.c_str());
    file.close();
    return def;
}

References Settings::localDataDir, pathJoin(), and settings.

Referenced by readValue2().

readValue2()

int TestMain::readValue2 ( const int  ver )

private

Definition at line 319 of file testmain.cpp.

{
    const int def = readValue(ver, 0);
    log->log("value for %d = %d", ver, def);
    return def;
}

References Logger::log(), log, and readValue().

Referenced by exec().

testsMain()

void TestMain::testsMain ( )

private

writeConfig()

void TestMain::writeConfig ( const RenderType  openGLMode, const int  rescale, const int  sound, const std::string &  info, const int  batchSize, const std::string &  textureSize, const int  detectMode  )

private

Definition at line 277 of file testmain.cpp.

{
    mConfig.init(settings.configDir + "/config.xml",
        UseVirtFs_false,
        SkipError_false);
 
    log->log("set mode to %d", CAST_S32(openGLMode));
 
    // searched values
    mConfig.setValue("opengl", CAST_S32(openGLMode));
    mConfig.setValue("showBackground", rescale == 0);
    mConfig.setValue("sound", sound == 0);
 
    // better performance
    mConfig.setValue("hwaccel", true);
    mConfig.setValue("fpslimit", 60);
    mConfig.setValue("altfpslimit", 2);
    mConfig.setValue("safemode", false);
    mConfig.setValue("enableMapReduce", true);
    mConfig.setValue("textureSize", textureSize);
 
    // max batch size
//    mConfig.setValue("batchsize", batchSize);
 
    // additional modes
    mConfig.setValue("useTextureSampler",
        static_cast<bool>(detectMode & 1024));
    mConfig.setValue("compresstextures",
        static_cast<bool>(detectMode & 2048));
 
    // stats
    mConfig.setValue("testInfo", info);
 
    mConfig.write();
}

References CAST_S32, Settings::configDir, Actions::info(), Configuration::init(), Logger::log(), log, mConfig, openGLMode, settings, Configuration::setValue(), SkipError_false, UseVirtFs_false, and Configuration::write().

Referenced by exec().

Field Documentation

log

Logger* TestMain::log

private

Definition at line 88 of file testmain.h.

Referenced by invokeModernOpenGLRenderTest(), invokeNormalOpenGLRenderTest(), invokeSafeOpenGLRenderTest(), invokeSoftwareRenderTest(), invokeTest4(), readValue2(), TestMain(), writeConfig(), and ~TestMain().

mConfig

Configuration TestMain::mConfig

private

Definition at line 90 of file testmain.h.

Referenced by getConfig(), initConfig(), invokeMobileOpenBatchTest(), invokeModernOpenBatchTest(), invokeModernOpenGLRenderTest(), invokeNormalOpenBatchTest(), invokeNormalOpenGLRenderTest(), invokeSafeOpenBatchTest(), invokeSafeOpenGLRenderTest(), invokeSoftwareRenderTest(), invokeTest(), invokeTest4(), and writeConfig().

---

The documentation for this class was generated from the following files:

• src/test/testmain.h (986a3bf)
• src/test/testmain.cpp (986a3bf)