bool StressTest::GoToNextPage()
{
double pageRenderTime = currPageRenderTime.GetTimeInMs();
ScopedMem<TCHAR> s(str::Format(_T("Page %d rendered in %d milliseconds"), currPage, (int)pageRenderTime));
ShowNotification(win, s, true, false, NG_STRESS_TEST_BENCHMARK);
++currPage;
while (!IsInRange(pageRanges, currPage) && currPage <= win->dm->PageCount()) {
currPage++;
}
if (currPage > win->dm->PageCount()) {
if (GoToNextFile())
return true;
Finished(true);
return false;
}
win->dm->GoToPage(currPage, 0);
currPageRenderTime.Start();
// start text search when we're in the middle of the document, so that
// search thread touches both pages that were already rendered and not yet
// rendered
// TODO: it would be nice to also randomize search starting page but the
// current API doesn't make it easy
if (currPage == pageForSearchStart) {
// use text that is unlikely to be found, so that we search all pages
win::SetText(win->hwndFindBox, _T("!z_yt"));
FindTextOnThread(win);
}
if (1 == rand() % 3) {
ClientRect rect(win->hwndFrame);
int deltaX = (rand() % 40) - 23;
rect.dx += deltaX;
if (rect.dx < 300)
rect.dx += (abs(deltaX) * 3);
int deltaY = (rand() % 40) - 23;
rect.dy += deltaY;
if (rect.dy < 300)
rect.dy += (abs(deltaY) * 3);
SendMessage(win->hwndFrame, WM_SIZE, 0, MAKELONG(rect.dx, rect.dy));
}
return true;
}
void StressTest::OnTimer(int timerIdGot)
{
CrashIf(timerId != timerIdGot);
KillTimer(win->hwndFrame, timerId);
if (!win->IsDocLoaded()) {
if (!GoToNextFile()) {
Finished(true);
return;
}
TickTimer();
return;
}
// chm documents aren't rendered and we block until we show them
// so we can assume previous page has been shown and go to next page
if (!win->AsFixed()) {
if (!GoToNextPage())
return;
goto Next;
}
// For non-image files, we detect if a page was rendered by checking the cache
// (but we don't wait more than 3 seconds).
// Image files are always fully rendered in WM_PAINT, so we know the page
// has already been rendered.
DisplayModel *dm = win->AsFixed();
bool didRender = gRenderCache.Exists(dm, currPage, dm->GetRotation());
if (!didRender && dm->ShouldCacheRendering(currPage)) {
double timeInMs = currPageRenderTime.GetTimeInMs();
if (timeInMs > 3.0 * 1000) {
if (!GoToNextPage())
return;
}
}
else if (!GoToNextPage()) {
return;
}
MakeRandomSelection(win, currPage);
Next:
TickTimer();
}
void StressTest::Start(const TCHAR *path, const TCHAR *filter, const TCHAR *ranges, int cycles)
{
srand((unsigned int)time(NULL));
GetSystemTime(&stressStartTime);
// forbid entering sleep mode during tests
SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED);
basePath.Set(str::Dup(path));
fileFilter.Set(filter && !str::Eq(filter, _T("*")) ? str::Dup(filter) : NULL);
if (file::Exists(basePath)) {
filesToOpen.Append(str::Dup(basePath));
ParsePageRanges(ranges, pageRanges);
}
else if (dir::Exists(basePath)) {
OpenDir(basePath);
ParsePageRanges(ranges, fileRanges);
}
else {
// Note: dev only, don't translate
ScopedMem<TCHAR> s(str::Format(_T("Path '%s' doesn't exist"), path));
ShowNotification(win, s, false /* autoDismiss */, true, NG_STRESS_TEST_SUMMARY);
Finished(false);
return;
}
this->cycles = cycles;
if (pageRanges.Count() == 0)
pageRanges.Append(PageRange());
if (fileRanges.Count() == 0)
fileRanges.Append(PageRange());
if (GoToNextFile())
TickTimer();
else
Finished(true);
}
int vtUnzip::Extract(bool bFullPath, bool bOverwrite, const char *lpszDst,
bool progress_callback(int))
{
int iCount = 0;
int iTotal = GetGlobalCount();
bool bOK = true;
for (bool bContinue = GoToFirstFile(); bContinue; bContinue = GoToNextFile())
{
char szFileName[MAX_PATH];
unz_file_info info;
bOK = GetCurrentFileInfo(&info, szFileName, MAX_PATH);
if (!bOK)
break;
vtString src_filename = szFileName;
const char *short_fname = (const char *)src_filename;
for (const char *p = short_fname;
(*p) != '\0';
p++)
{
if (((*p)=='/') || ((*p)=='\\'))
{
short_fname = p+1;
}
}
vtString short_filename = short_fname;
if ((*short_filename)=='\0')
{
if (bFullPath)
{
VTLOG("creating directory: %s\n", (const char *)src_filename);
vtCreateDir(src_filename);
}
}
else
{
bOK = OpenCurrentFile();
if (bOK)
{
vtString write_filename;
write_filename = vtString(lpszDst) + (bFullPath ? src_filename : short_filename);
vtString strResult;
VTLOG("Extracting %s ...", (const char *) write_filename);
if (ExtractAccept(write_filename, bOverwrite))
{
FILE* file = vtFileOpen(write_filename, "wb");
bool bWrite = (file != NULL);
if (bWrite)
{
char buf[4096];
bWrite = ExtractCurrentFile(file, buf, 4096);
fclose(file);
}
if (bWrite)
{
vtUnzip::change_file_date(write_filename,info.dosDate, info.tmu_date);
iCount++;
if (progress_callback != NULL)
{
progress_callback(iCount * 99 / iTotal);
}
}
else
{
m_error_count++;
OnError(write_filename);
}
strResult = bWrite ? "ok" : "failed";
}
else
{
strResult = "skipped";
}
VTLOG(" %s\n", (const char *) strResult);
CloseCurrentFile();
}
}
}
if (bOK)
return iCount;
else
return -1;
}
