String
SpamTestSPF::GetName() const
{
return GetTestName();
}
int main(int argc, const char* argv[])
{
#ifdef ANDROID_NDK_PROFILER
setenv("CPUPROFILE_FREQUENCY", "500", 1);
setenv("CPUPROFILE", "/sdcard/gmon.out", 1);
monstartup("ppsspp_headless");
#endif
bool fullLog = false;
bool useJit = true;
bool autoCompare = false;
bool verbose = false;
const char *stateToLoad = 0;
GPUCore gpuCore = GPU_NULL;
std::vector<std::string> testFilenames;
const char *mountIso = 0;
const char *screenshotFilename = 0;
bool readMount = false;
float timeout = std::numeric_limits<float>::infinity();
for (int i = 1; i < argc; i++)
{
if (readMount)
{
mountIso = argv[i];
readMount = false;
continue;
}
if (!strcmp(argv[i], "-m") || !strcmp(argv[i], "--mount"))
readMount = true;
else if (!strcmp(argv[i], "-l") || !strcmp(argv[i], "--log"))
fullLog = true;
else if (!strcmp(argv[i], "-i"))
useJit = false;
else if (!strcmp(argv[i], "-j"))
useJit = true;
else if (!strcmp(argv[i], "-c") || !strcmp(argv[i], "--compare"))
autoCompare = true;
else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--verbose"))
verbose = true;
else if (!strncmp(argv[i], "--graphics=", strlen("--graphics=")) && strlen(argv[i]) > strlen("--graphics="))
{
const char *gpuName = argv[i] + strlen("--graphics=");
if (!strcasecmp(gpuName, "gles"))
gpuCore = GPU_GLES;
else if (!strcasecmp(gpuName, "software"))
gpuCore = GPU_SOFTWARE;
else if (!strcasecmp(gpuName, "directx9"))
gpuCore = GPU_DIRECTX9;
else if (!strcasecmp(gpuName, "null"))
gpuCore = GPU_NULL;
else
{
printUsage(argv[0], "Unknown gpu backend specified after --graphics=");
return 1;
}
}
// Default to GLES if no value selected.
else if (!strcmp(argv[i], "--graphics"))
gpuCore = GPU_GLES;
else if (!strncmp(argv[i], "--screenshot=", strlen("--screenshot=")) && strlen(argv[i]) > strlen("--screenshot="))
screenshotFilename = argv[i] + strlen("--screenshot=");
else if (!strncmp(argv[i], "--timeout=", strlen("--timeout=")) && strlen(argv[i]) > strlen("--timeout="))
timeout = strtod(argv[i] + strlen("--timeout="), NULL);
else if (!strcmp(argv[i], "--teamcity"))
teamCityMode = true;
else if (!strncmp(argv[i], "--state=", strlen("--state=")) && strlen(argv[i]) > strlen("--state="))
stateToLoad = argv[i] + strlen("--state=");
else if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h"))
{
printUsage(argv[0], NULL);
return 1;
}
else
testFilenames.push_back(argv[i]);
}
// TODO: Allow a filename here?
if (testFilenames.size() == 1 && testFilenames[0] == "@-")
{
testFilenames.clear();
char temp[2048];
temp[2047] = '\0';
while (scanf("%2047s", temp) == 1)
testFilenames.push_back(temp);
}
if (readMount)
{
printUsage(argv[0], "Missing argument after -m");
return 1;
}
if (testFilenames.empty())
{
printUsage(argv[0], argc <= 1 ? NULL : "No executables specified");
return 1;
}
HeadlessHost *headlessHost = getHost(gpuCore);
host = headlessHost;
std::string error_string;
bool glWorking = host->InitGL(&error_string);
LogManager::Init();
LogManager *logman = LogManager::GetInstance();
PrintfLogger *printfLogger = new PrintfLogger();
for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; i++)
{
LogTypes::LOG_TYPE type = (LogTypes::LOG_TYPE)i;
logman->SetEnable(type, fullLog);
logman->SetLogLevel(type, LogTypes::LDEBUG);
logman->AddListener(type, printfLogger);
}
CoreParameter coreParameter;
coreParameter.cpuCore = useJit ? CPU_JIT : CPU_INTERPRETER;
coreParameter.gpuCore = glWorking ? gpuCore : GPU_NULL;
coreParameter.enableSound = false;
coreParameter.mountIso = mountIso ? mountIso : "";
coreParameter.startPaused = false;
coreParameter.printfEmuLog = !autoCompare;
coreParameter.headLess = true;
coreParameter.renderWidth = 480;
coreParameter.renderHeight = 272;
coreParameter.pixelWidth = 480;
coreParameter.pixelHeight = 272;
coreParameter.unthrottle = true;
g_Config.bEnableSound = false;
g_Config.bFirstRun = false;
g_Config.bIgnoreBadMemAccess = true;
// Never report from tests.
g_Config.sReportHost = "";
g_Config.bAutoSaveSymbolMap = false;
g_Config.iRenderingMode = 0;
g_Config.bHardwareTransform = true;
#ifdef USING_GLES2
g_Config.iAnisotropyLevel = 0;
#else
g_Config.iAnisotropyLevel = 8;
#endif
g_Config.bVertexCache = true;
g_Config.bTrueColor = true;
g_Config.iLanguage = PSP_SYSTEMPARAM_LANGUAGE_ENGLISH;
g_Config.iTimeFormat = PSP_SYSTEMPARAM_TIME_FORMAT_24HR;
g_Config.bEncryptSave = true;
g_Config.sNickName = "shadow";
g_Config.iTimeZone = 60;
g_Config.iDateFormat = PSP_SYSTEMPARAM_DATE_FORMAT_DDMMYYYY;
g_Config.iButtonPreference = PSP_SYSTEMPARAM_BUTTON_CROSS;
g_Config.iLockParentalLevel = 9;
g_Config.iInternalResolution = 1;
g_Config.bFrameSkipUnthrottle = false;
g_Config.bEnableLogging = fullLog;
g_Config.iNumWorkerThreads = 1;
g_Config.iBGMVolume = MAX_CONFIG_VOLUME;
g_Config.iSFXVolume = MAX_CONFIG_VOLUME;
g_Config.bSoftwareSkinning = true;
g_Config.bVertexDecoderJit = true;
#ifdef _WIN32
InitSysDirectories();
#endif
#if defined(ANDROID)
#elif defined(BLACKBERRY) || defined(__SYMBIAN32__)
#elif !defined(_WIN32)
g_Config.memCardDirectory = std::string(getenv("HOME")) + "/.ppsspp/";
#endif
// Try to find the flash0 directory. Often this is from a subdirectory.
for (int i = 0; i < 3; ++i)
{
if (!File::Exists(g_Config.flash0Directory))
g_Config.flash0Directory += "../../flash0/";
}
// Or else, maybe in the executable's dir.
if (!File::Exists(g_Config.flash0Directory))
g_Config.flash0Directory = File::GetExeDirectory() + "flash0/";
if (screenshotFilename != 0)
headlessHost->SetComparisonScreenshot(screenshotFilename);
#ifdef ANDROID
// For some reason the debugger installs it with this name?
if (File::Exists("/data/app/org.ppsspp.ppsspp-2.apk")) {
VFSRegister("", new ZipAssetReader("/data/app/org.ppsspp.ppsspp-2.apk", "assets/"));
}
if (File::Exists("/data/app/org.ppsspp.ppsspp.apk")) {
VFSRegister("", new ZipAssetReader("/data/app/org.ppsspp.ppsspp.apk", "assets/"));
}
#endif
if (stateToLoad != NULL)
SaveState::Load(stateToLoad);
std::vector<std::string> failedTests;
std::vector<std::string> passedTests;
for (size_t i = 0; i < testFilenames.size(); ++i)
{
coreParameter.fileToStart = testFilenames[i];
if (autoCompare)
printf("%s:\n", coreParameter.fileToStart.c_str());
bool passed = RunAutoTest(headlessHost, coreParameter, autoCompare, verbose, timeout);
if (autoCompare)
{
std::string testName = GetTestName(coreParameter.fileToStart);
if (passed)
{
passedTests.push_back(testName);
printf(" %s - passed!\n", testName.c_str());
}
else
failedTests.push_back(testName);
}
}
if (autoCompare)
{
printf("%d tests passed, %d tests failed.\n", (int)passedTests.size(), (int)failedTests.size());
if (!failedTests.empty())
{
printf("Failed tests:\n");
for (size_t i = 0; i < failedTests.size(); ++i) {
printf(" %s\n", failedTests[i].c_str());
}
}
}
host->ShutdownGL();
delete host;
host = NULL;
headlessHost = NULL;
#ifdef ANDROID_NDK_PROFILER
moncleanup();
#endif
return 0;
}
bool CompareOutput(const std::string &bootFilename, const std::string &output, bool verbose)
{
std::string expect_filename = ExpectedFromFilename(bootFilename);
std::ifstream expect_f;
expect_f.open(expect_filename.c_str(), std::ios::in);
if (!expect_f.fail())
{
BufferedLineReaderFile expected(expect_f);
BufferedLineReader actual(output);
bool failed = false;
while (expected.HasLines())
{
if (expected.Compare(actual))
continue;
if (!failed)
{
TeamCityPrint("##teamcity[testFailed name='%s' message='Output different from expected file']\n", teamCityName.c_str());
failed = true;
}
// This is a really dirt simple comparing algorithm.
// Perhaps it was an extra line?
if (expected.Peek(0) == actual.Peek(1) || !expected.HasLines())
printf("+ %s\n", actual.Consume().c_str());
// A single missing line?
else if (expected.Peek(1) == actual.Peek(0) || !actual.HasLines())
printf("- %s\n", expected.Consume().c_str());
else
{
printf("O %s\n", actual.Consume().c_str());
printf("E %s\n", expected.Consume().c_str());
}
}
while (actual.HasLines())
{
// If it's a blank line, this will pass.
if (actual.Compare(expected))
continue;
printf("+ %s\n", actual.Consume().c_str());
}
expect_f.close();
if (verbose)
{
if (!failed)
{
printf("++++++++++++++ The Equal Output +++++++++++++\n");
printf("%s", output.c_str());
printf("+++++++++++++++++++++++++++++++++++++++++++++\n");
}
else
{
printf("============== output from failed %s:\n", GetTestName(bootFilename).c_str());
printf("%s", output.c_str());
printf("============== expected output:\n");
std::string fullExpected;
if (readFileToString(true, expect_filename.c_str(), fullExpected))
printf("%s", fullExpected.c_str());
printf("===============================\n");
}
}
return !failed;
}
else
{
fprintf(stderr, "Expectation file %s not found\n", expect_filename.c_str());
TeamCityPrint("##teamcity[testIgnored name='%s' message='Expects file missing']\n", teamCityName.c_str());
return false;
}
}
bool RunAutoTest(HeadlessHost *headlessHost, CoreParameter &coreParameter, bool autoCompare, bool verbose, double timeout)
{
if (teamCityMode) {
// Kinda ugly, trying to guesstimate the test name from filename...
teamCityName = GetTestName(coreParameter.fileToStart);
}
std::string output;
if (autoCompare)
coreParameter.collectEmuLog = &output;
std::string error_string;
if (!PSP_Init(coreParameter, &error_string)) {
fprintf(stderr, "Failed to start %s. Error: %s\n", coreParameter.fileToStart.c_str(), error_string.c_str());
printf("TESTERROR\n");
TeamCityPrint("##teamcity[testIgnored name='%s' message='PRX/ELF missing']\n", teamCityName.c_str());
return false;
}
TeamCityPrint("##teamcity[testStarted name='%s' captureStandardOutput='true']\n", teamCityName.c_str());
host->BootDone();
if (autoCompare)
headlessHost->SetComparisonScreenshot(ExpectedScreenshotFromFilename(coreParameter.fileToStart));
time_update();
bool passed = true;
// TODO: We must have some kind of stack overflow or we're not following the ABI right.
// This gets trashed if it's not static.
static double deadline;
deadline = time_now() + timeout;
coreState = CORE_RUNNING;
while (coreState == CORE_RUNNING)
{
int blockTicks = usToCycles(1000000 / 10);
PSP_RunLoopFor(blockTicks);
// If we were rendering, this might be a nice time to do something about it.
if (coreState == CORE_NEXTFRAME) {
coreState = CORE_RUNNING;
headlessHost->SwapBuffers();
}
time_update();
if (time_now_d() > deadline) {
// Don't compare, print the output at least up to this point, and bail.
printf("%s", output.c_str());
passed = false;
host->SendDebugOutput("TIMEOUT\n");
TeamCityPrint("##teamcity[testFailed name='%s' message='Test timeout']\n", teamCityName.c_str());
Core_Stop();
}
}
PSP_Shutdown();
headlessHost->FlushDebugOutput();
if (autoCompare && passed)
passed = CompareOutput(coreParameter.fileToStart, output, verbose);
TeamCityPrint("##teamcity[testFinished name='%s']\n", teamCityName.c_str());
return passed;
}
static bool
test_cruise_efficiency(int test_num, int n_wind)
{
// tests functionality of cruise efficiency calculations
double ce0, ce1, ce2, ce3, ce4, ce5, ce6;
autopilot_parms.SetIdeal();
TestFlightResult result = test_flight(test_num, n_wind);
ce0 = result.calc_cruise_efficiency;
// wandering
autopilot_parms.SetRealistic();
result = test_flight(test_num, n_wind);
ce1 = result.calc_cruise_efficiency;
// cruise efficiency of this should be lower than nominal
if (ce0 <= ce1 || verbose)
printf("# calc cruise efficiency %g\n", result.calc_cruise_efficiency);
ok(ce0 > ce1, GetTestName("ce wandering", test_num, n_wind), 0);
// flying too slow
autopilot_parms.SetIdeal();
result = test_flight(test_num, n_wind, 0.8);
ce2 = result.calc_cruise_efficiency;
// cruise efficiency of this should be lower than nominal
if (ce0 <= ce2 || verbose)
printf("# calc cruise efficiency %g\n", result.calc_cruise_efficiency);
ok(ce0 > ce2, GetTestName("ce speed slow", test_num, n_wind), 0);
// flying too fast
autopilot_parms.SetIdeal();
result = test_flight(test_num, n_wind, 1.2);
ce3 = result.calc_cruise_efficiency;
// cruise efficiency of this should be lower than nominal
if (ce0 <= ce3 || verbose)
printf("# calc cruise efficiency %g\n", result.calc_cruise_efficiency);
ok(ce0 > ce3, GetTestName("ce speed fast", test_num, n_wind), 0);
// higher than expected cruise sink
autopilot_parms.sink_factor = fixed(1.2);
result = test_flight(test_num, n_wind);
ce4 = result.calc_cruise_efficiency;
if (ce0 <= ce4 || verbose)
printf("# calc cruise efficiency %g\n", result.calc_cruise_efficiency);
ok(ce0 > ce4, GetTestName("ce high sink", test_num, n_wind), 0);
// cruise efficiency of this should be lower than nominal
autopilot_parms.sink_factor = fixed(1.0);
// slower than expected climb
autopilot_parms.climb_factor = fixed(0.8);
result = test_flight(test_num, n_wind);
ce5 = result.calc_cruise_efficiency;
if (ce0 <= ce5 || verbose)
printf("# calc cruise efficiency %g\n", result.calc_cruise_efficiency);
ok(ce0 > ce5, GetTestName("ce slow climb", test_num, n_wind), 0);
// cruise efficiency of this should be lower than nominal
autopilot_parms.climb_factor = fixed(1.0);
// lower than expected cruise sink;
autopilot_parms.sink_factor = fixed(0.8);
result = test_flight(test_num, n_wind);
ce6 = result.calc_cruise_efficiency;
if (ce0 >= ce6 || verbose)
printf("# calc cruise efficiency %g\n", result.calc_cruise_efficiency);
ok(ce0 < ce6, GetTestName("ce low sink", test_num, n_wind), 0);
// cruise efficiency of this should be greater than nominal
autopilot_parms.sink_factor = fixed(1.0);
bool retval = (ce0 > ce1) && (ce0 > ce2) && (ce0 > ce3) && (ce0 > ce4)
&& (ce0 > ce5) && (ce0 < ce6);
if (verbose || !retval) {
printf("# ce nominal %g\n", ce0);
printf("# ce wandering %g\n", ce1);
printf("# ce speed slow %g\n", ce2);
printf("# ce speed fast %g\n", ce3);
printf("# ce high sink %g\n", ce4);
printf("# ce slow climb %g\n", ce5);
printf("# ce low sink %g\n", ce6);
}
return retval;
}
