#include "SkBitmap.h" #include "SkCanvas.h" #include "SkColor.h" #include "SkColorPriv.h" #include "SkDevice.h" #include "SkGraphics.h" #include "SkImageDecoder.h" #include "SkImageEncoder.h" #include "SkOSFile.h" #include "SkPathOpsDebug.h" #include "SkPicture.h" #include "SkRTConf.h" #include "SkTSort.h" #include "SkStream.h" #include "SkString.h" #include "SkTArray.h" #include "SkTDArray.h" #include "SkThreadPool.h" #include "SkTime.h" #include "Test.h" #ifdef SK_BUILD_FOR_WIN #define PATH_SLASH "\\" #define IN_DIR "D:\\skp\\slave" #define OUT_DIR "D:\\skpOut\\1\\" #else #define PATH_SLASH "/" #define IN_DIR "/skp/2311328-7fc2228/slave" #define OUT_DIR "/skpOut/4/" #endif const struct { int directory; const char* filename; } skipOverSept[] = { { 3, "http___www_americascup_com_.skp"}, // !simple->closed() {18, "http___www_argus_presse_fr_.skp"}, // can't find winding of remaining vertical edge {31, "http___www_narayana_verlag_de_.skp"}, // !simple->closed() {36, "http___www_educationalcraft_com_.skp"}, // cubic / cubic near end / assert in SkIntersections::insert {44, "http___www_cooksnaps_com_.skp"}, // !simple->isClosed() {48, "http___www_narayana_publishers_com_.skp"}, // !simple->isClosed() {51, "http___www_freedominthe50states_org_.skp"}, // corrupt dash data {52, "http___www_aceinfographics_com_.skp"}, // right angle winding assert {53, "http___www_lojaanabotafogo_com_br_.skp"}, // rrect validate assert {57, "http___www_vantageproduction_com_.skp"}, // !isClosed() {64, "http___www_etiqadd_com_.skp"}, // !simple->closed() {84, "http___www_swapspacesystems_com_.skp"}, // !simple->closed() {90, "http___www_tcmevents_org_.skp"}, // !simple->closed() {96, "http___www_paseoitaigara_com_br_.skp"}, // !simple->closed() {98, "http___www_mortgagemarketguide_com_.skp"}, // !simple->closed() {99, "http___www_kitcheninspirations_wordpress_com_.skp"}, // checkSmall / bumpSpan }; /* stats 97 http___www_brandyandvinca_com_.skp pixelError=3 95 http___www_into_asia_com_.skp pixelError=12 93 http___www_lunarplanner_com_.skp pixelError=14 98 http___www_lovelyitalia_com_.skp pixelError=17 90 http___www_inter_partner_blogspot_com_.skp pixelError=18 99 http___www_maxarea_com_.skp pixelError=26 98 http___www_maroonsnet_org_.skp pixelError=33 92 http___www_belinaart_ru_.skp pixelError=50 100 http___www_chroot_ro_.skp pixelError=62 99 http___www_hsbrands_com_.skp pixelError=98 95 http___www_tournamentindicator_com_.skp pixelError=122 93 http___www_businesses_com_au_.skp pixelError=162 90 http___www_regenesys_net_.skp pixelError=182 88 http___www_1863544208148625103_c18eac63985503fa85b06358959c1ba27fc36f82_blogspot_com_.skp pixelError=186 97 http___www_pregacoesevangelica_com_br_.skp pixelError=240 77 http___www_zhenggang_org_.skp pixelError=284 96 http___slidesharemailer_com_.skp pixelError=522 94 http___www_gensteel_com_.skp pixelError=555 68 http___www_jf_eti_br_.skp pixelError=610 83 http___www_swishiat_com_.skp pixelError=706 96 http___www_matusikmissive_com_au_.skp pixelError=2580 95 http___www_momentumnation_com_.skp pixelError=3938 92 http___www_rssowl_com_.skp pixelError=5113 96 http___www_sexxygirl_tv_.skp pixelError=7605 99 http___www_georgevalah_wordpress_com_.skp pixelError=8386 78 http___www_furbo_org_.skp pixelError=8656 78 http___www_djxhemary_wordpress_com_.skp pixelError=8976 100 http___www_mindcontrolblackassassins_com_.skp pixelError=31950 98 http___bababillgates_free_fr_.skp pixelError=40237 98 http___hepatite_ro_.skp pixelError=44370 86 http___www_somethingwagging_com_.skp pixelError=47794 84 http___www_beverageuniverse_com_.skp pixelError=65450 50 http___www_aveksa_com_.skp pixelError=68194 10 http___www_publiker_pl_.skp pixelError=89997 61 http___www_dominos_co_id_.skp pixelError=476868 87 http___www_du_edu_om_.skp time=46 87 http___www_bigload_de_.skp time=46 100 http___www_home_forum_com_.skp time=48 97 http___www_hotamateurchat_com_.skp time=48 97 http___www_myrsky_com_cn_.skp time=48 98 http___www_techiegeex_com_.skp time=49 82 http___www_fashionoutletsofchicago_com_.skp time=50 77 http___www_dynamischbureau_nl_.skp time=50 82 http___www_mayihelpu_co_in_.skp time=50 84 http___www_vbox7_com_user_history_viewers_.skp time=50 85 http___www_ktokogda_com_.skp time=50 85 http___www_propertyturkeysale_com_.skp time=50 85 http___www_51play_com_.skp time=50 86 http___www_bayalarm_com_.skp time=50 87 http___www_eaglepictures_com_.skp time=50 88 http___www_atlasakvaryum_com_.skp time=50 91 http___www_pioneerchryslerjeep_com_.skp time=50 94 http___www_thepulsemag_com_.skp time=50 95 http___www_dcshoes_com_ph_.skp time=50 96 http___www_montrealmassage_ca_.skp time=50 96 http___www_jkshahclasses_com_.skp time=50 96 http___www_webcamconsult_com_.skp time=51 100 http___www_bsoscblog_com_.skp time=52 95 http___www_flaktwoods_com_.skp time=53 91 http___www_qivivo_com_.skp time=54 90 http___www_unitender_com_.skp time=56 97 http___www_casinogaming_com_.skp time=56 97 http___www_rootdownload_com_.skp time=56 94 http___www_aspa_ev_de_.skp time=57 98 http___www_tenpieknyswiat_pl_.skp time=57 93 http___www_transocean_de_.skp time=58 94 http___www_vdo2_blogspot_com_.skp time=58 94 http___www_asmaissexy_com_br_.skp time=58 100 http___www_prefeiturasjm_com_br_.skp time=60 100 http___www_eduinsuranceclick_blogspot_com_.skp time=60 96 http___www_bobdunsire_com_.skp time=61 96 http___www_omgkettlecorn_com_.skp time=61 85 http___www_fbbsessions_com_.skp time=62 86 http___www_hector_ru_.skp time=62 87 http___www_wereldsupporter_nl_.skp time=62 90 http___www_arello_com_.skp time=62 93 http___www_bayerplastics_com_.skp time=62 93 http___www_superandolamovida_com_ar_.skp time=62 96 http___www_med_rbf_ru_.skp time=62 81 http___www_carnegiescience_edu_.skp time=65 87 http___www_asanewengland_com_.skp time=65 92 http___www_turkce_karakter_appspot_com_.skp time=65 94 http___www_k3a_org_.skp time=65 96 http___www_powermaccenter_com_.skp time=65 98 http___www_avto49_ru_.skp time=67 100 http___www_hetoldeambaecht_nl_.skp time=68 95 http___www_marine_ie_.skp time=69 96 http___www_quebecvapeboutique_com_.skp time=69 95 http___www_brays_ingles_com_.skp time=70 100 http___www_lacondesa_com_.skp time=72 95 http___www_timbarrathai_com_au_.skp time=76 95 http___www_cuissedegrenouille_com_.skp time=76 95 http___www_iwama51_ru_.skp time=76 99 http___www_fotoantologia_it_.skp time=76 92 http___www_indian_architects_com_.skp time=78 92 http___www_totalwomanspa_com_.skp time=78 100 http___www_fachverband_spielhallen_de_.skp time=83 93 http___www_golshanemehr_ir_.skp time=84 95 http___www_maryesses_com_.skp time=84 99 http___www_ddcorp_ca_.skp time=89 90 http___www_brontops_com_.skp time=89 94 http___www_robgolding_com_.skp time=89 91 http___www_tecban_com_br_.skp time=91 98 http___www_costamesakarate_com_.skp time=100 95 http___www_monsexyblog_com_.skp time=103 97 http___www_stornowaygazette_co_uk_.skp time=103 93 http___www_fitforaframe_com_.skp time=104 98 http___www_intentionoftheday_com_.skp time=113 100 http___www_tailgateclothing_com_.skp time=117 95 http___www_senbros_com_.skp time=118 93 http___www_lettoblog_com_.skp time=121 94 http___www_maxineschallenge_com_au_.skp time=125 95 http___www_savvycard_net_.skp time=127 95 http___www_open_ac_mu_.skp time=129 96 http___www_avgindia_in_.skp time=135 97 http___www_stocktonseaview_com_.skp time=135 96 http___www_distroller_com_.skp time=142 94 http___www_travoggalop_dk_.skp time=144 100 http___www_history_im_.skp time=144 94 http___www_playradio_sk_.skp time=145 92 http___www_linglongglass_com_.skp time=151 97 http___www_bizzna_com_.skp time=151 96 http___www_spiros_ws_.skp time=154 91 http___www_rosen_meents_co_il_.skp time=156 81 http___www_hoteldeluxeportland_com_.skp time=158 92 http___www_freetennis_org_.skp time=161 93 http___www_aircharternetwork_com_au_.skp time=161 94 http___www_austinparks_org_.skp time=165 89 http___www_bevvy_co_.skp time=168 91 http___www_sosyalhile_net_.skp time=168 98 http___www_minvih_gob_ve_.skp time=171 89 http___www_streetfoodmtl_com_.skp time=172 92 http___www_loveslatinas_tumblr_com_.skp time=178 93 http___www_madbites_co_in_.skp time=180 94 http___www_rocktarah_ir_.skp time=185 97 http___www_penthouselife_com_.skp time=185 96 http___www_appymonkey_com_.skp time=196 92 http___www_pasargadhotels_com_.skp time=203 99 http___www_marina_mil_pe_.skp time=203 89 http___www_kays_co_uk_.skp time=205 77 http___www_334588_com_.skp time=211 83 http___www_trendbad24_de_.skp time=211 81 http___www_cdnetworks_co_kr_.skp time=216 94 http___www_schellgames_com_.skp time=223 95 http___www_juliaweddingnews_cn_.skp time=230 92 http___www_xcrafters_pl_.skp time=253 93 http___www_pondoo_com_.skp time=253 96 http___www_helsinkicapitalpartners_fi_.skp time=255 88 http___www_nadtexican_com_.skp time=259 85 http___www_canstockphoto_hu_.skp time=266 78 http___www_ecovacs_com_cn_.skp time=271 93 http___www_brookfieldplaceny_com_.skp time=334 93 http___www_fmastrengthtraining_com_.skp time=337 94 http___www_turtleonthebeach_com_.skp time=394 90 http___www_temptationthemovie_com_.skp time=413 95 http___www_patongsawaddi_com_.skp time=491 91 http___www_online_radio_appspot_com_.skp time=511 68 http___www_richardmiller_co_uk_.skp time=528 63 http___www_eschrade_com_.skp time=543 55 http___www_interaction_inf_br_.skp time=625 38 http___www_huskyliners_com_.skp time=632 86 http___granda_net_.skp time=1067 24 http___www_cocacolafm_com_br_.skp time=1081 */ size_t skipOverSeptCount = sizeof(skipOverSept) / sizeof(skipOverSept[0]); enum TestStep { kCompareBits, kEncodeFiles, }; enum { kMaxLength = 256, kMaxFiles = 128, kSmallLimit = 1000, }; struct TestResult { void init(int dirNo) { fDirNo = dirNo; sk_bzero(fFilename, sizeof(fFilename)); fTestStep = kCompareBits; fScale = 1; } SkString status() { SkString outStr; outStr.printf("%s %d %d\n", fFilename, fPixelError, fTime); return outStr; } SkString progress() { SkString outStr; outStr.printf("dir=%d %s ", fDirNo, fFilename); if (fPixelError) { outStr.appendf(" err=%d", fPixelError); } if (fTime) { outStr.appendf(" time=%d", fTime); } if (fScale != 1) { outStr.appendf(" scale=%d", fScale); } outStr.appendf("\n"); return outStr; } static void Test(int dirNo, const char* filename, TestStep testStep) { TestResult test; test.init(dirNo); test.fTestStep = testStep; strcpy(test.fFilename, filename); test.testOne(); } void test(int dirNo, const SkString& filename) { init(dirNo); strcpy(fFilename, filename.c_str()); testOne(); } void testOne(); char fFilename[kMaxLength]; TestStep fTestStep; int fDirNo; int fPixelError; int fTime; int fScale; }; class SortByPixel : public TestResult { public: bool operator<(const SortByPixel& rh) const { return fPixelError < rh.fPixelError; } }; class SortByTime : public TestResult { public: bool operator<(const SortByTime& rh) const { return fTime < rh.fTime; } }; class SortByName : public TestResult { public: bool operator<(const SortByName& rh) const { return strcmp(fFilename, rh.fFilename) < 0; } }; struct TestState { void init(int dirNo, skiatest::Reporter* reporter) { fReporter = reporter; fResult.init(dirNo); } SkTDArray fPixelWorst; SkTDArray fSlowest; skiatest::Reporter* fReporter; TestResult fResult; }; struct TestRunner { TestRunner(skiatest::Reporter* reporter, int threadCount) : fNumThreads(threadCount) , fReporter(reporter) { } ~TestRunner(); void render(); int fNumThreads; SkTDArray fRunnables; skiatest::Reporter* fReporter; }; class TestRunnable : public SkRunnable { public: virtual void run() SK_OVERRIDE { SkGraphics::SetTLSFontCacheLimit(1 * 1024 * 1024); (*fTestFun)(&fState); } TestState fState; void (*fTestFun)(TestState*); }; class TestRunnableDir : public TestRunnable { public: TestRunnableDir(void (*testFun)(TestState*), int dirNo, TestRunner* runner) { fState.init(dirNo, runner->fReporter); fTestFun = testFun; } }; class TestRunnableFile : public TestRunnable { public: TestRunnableFile(void (*testFun)(TestState*), int dirNo, const char* name, TestRunner* runner) { fState.init(dirNo, runner->fReporter); strcpy(fState.fResult.fFilename, name); fTestFun = testFun; } }; class TestRunnableEncode : public TestRunnableFile { public: TestRunnableEncode(void (*testFun)(TestState*), int dirNo, const char* name, TestRunner* runner) : TestRunnableFile(testFun, dirNo, name, runner) { fState.fResult.fTestStep = kEncodeFiles; } }; TestRunner::~TestRunner() { for (int index = 0; index < fRunnables.count(); index++) { SkDELETE(fRunnables[index]); } } void TestRunner::render() { SkThreadPool pool(fNumThreads); for (int index = 0; index < fRunnables.count(); ++ index) { pool.add(fRunnables[index]); } } //////////////////////////////////////////////// static const char outOpDir[] = OUT_DIR "opClip"; static const char outOldDir[] = OUT_DIR "oldClip"; static const char outSkpDir[] = OUT_DIR "skpTest"; static const char outDiffDir[] = OUT_DIR "outTest"; static const char outStatusDir[] = OUT_DIR "statusTest"; static SkString make_filepath(int dirNo, const char* dir, const char* name) { SkString path(dir); if (dirNo) { path.appendf("%d", dirNo); } path.append(PATH_SLASH); path.append(name); return path; } static SkString make_in_dir_name(int dirNo) { SkString dirName(IN_DIR); dirName.appendf("%d", dirNo); if (!sk_exists(dirName.c_str())) { SkDebugf("could not read dir %s\n", dirName.c_str()); return SkString(); } return dirName; } static SkString make_stat_dir_name(int dirNo) { SkString dirName(outStatusDir); dirName.appendf("%d", dirNo); if (!sk_exists(dirName.c_str())) { SkDebugf("could not read dir %s\n", dirName.c_str()); return SkString(); } return dirName; } static bool make_one_out_dir(const char* outDirStr) { SkString outDir = make_filepath(0, outDirStr, ""); if (!sk_exists(outDir.c_str())) { if (!sk_mkdir(outDir.c_str())) { SkDebugf("could not create dir %s\n", outDir.c_str()); return false; } } return true; } static bool make_out_dirs() { SkString outDir = make_filepath(0, OUT_DIR, ""); if (!sk_exists(outDir.c_str())) { if (!sk_mkdir(outDir.c_str())) { SkDebugf("could not create dir %s\n", outDir.c_str()); return false; } } return make_one_out_dir(outOldDir) && make_one_out_dir(outOpDir) && make_one_out_dir(outSkpDir) && make_one_out_dir(outDiffDir) && make_one_out_dir(outStatusDir); } static SkString make_png_name(const char* filename) { SkString pngName = SkString(filename); pngName.remove(pngName.size() - 3, 3); pngName.append("png"); return pngName; } static int similarBits(const SkBitmap& gr, const SkBitmap& sk) { const int kRowCount = 3; const int kThreshold = 3; int width = SkTMin(gr.width(), sk.width()); if (width < kRowCount) { return true; } int height = SkTMin(gr.height(), sk.height()); if (height < kRowCount) { return true; } int errorTotal = 0; SkTArray errorRows; errorRows.push_back_n(width * kRowCount); SkAutoLockPixels autoGr(gr); SkAutoLockPixels autoSk(sk); for (int y = 0; y < height; ++y) { SkPMColor* grRow = gr.getAddr32(0, y); SkPMColor* skRow = sk.getAddr32(0, y); int* base = &errorRows[0]; int* cOut = &errorRows[y % kRowCount]; for (int x = 0; x < width; ++x) { SkPMColor grColor = grRow[x]; SkPMColor skColor = skRow[x]; int dr = SkGetPackedR32(grColor) - SkGetPackedR32(skColor); int dg = SkGetPackedG32(grColor) - SkGetPackedG32(skColor); int db = SkGetPackedB32(grColor) - SkGetPackedB32(skColor); int error = cOut[x] = SkTMax(SkAbs32(dr), SkTMax(SkAbs32(dg), SkAbs32(db))); if (error < kThreshold || x < 2) { continue; } if (base[x - 2] < kThreshold || base[width + x - 2] < kThreshold || base[width * 2 + x - 2] < kThreshold || base[x - 1] < kThreshold || base[width + x - 1] < kThreshold || base[width * 2 + x - 1] < kThreshold || base[x] < kThreshold || base[width + x] < kThreshold || base[width * 2 + x] < kThreshold) { continue; } errorTotal += error; } } return errorTotal; } static bool addError(TestState* data, const TestResult& testResult) { if (testResult.fPixelError <= 0 && testResult.fTime <= 0) { return false; } int worstCount = data->fPixelWorst.count(); int pixelError = testResult.fPixelError; if (pixelError > 0) { for (int index = 0; index < worstCount; ++index) { if (pixelError > data->fPixelWorst[index].fPixelError) { data->fPixelWorst[index] = *(SortByPixel*) &testResult; return true; } } } int slowCount = data->fSlowest.count(); int time = testResult.fTime; if (time > 0) { for (int index = 0; index < slowCount; ++index) { if (time > data->fSlowest[index].fTime) { data->fSlowest[index] = *(SortByTime*) &testResult; return true; } } } if (pixelError > 0 && worstCount < kMaxFiles) { *data->fPixelWorst.append() = *(SortByPixel*) &testResult; return true; } if (time > 0 && slowCount < kMaxFiles) { *data->fSlowest.append() = *(SortByTime*) &testResult; return true; } return false; } static SkMSec timePict(SkPicture* pic, SkCanvas* canvas) { canvas->save(); int pWidth = pic->width(); int pHeight = pic->height(); const int maxDimension = 1000; const int slices = 3; int xInterval = SkTMax(pWidth - maxDimension, 0) / (slices - 1); int yInterval = SkTMax(pHeight - maxDimension, 0) / (slices - 1); SkRect rect = {0, 0, SkIntToScalar(SkTMin(maxDimension, pWidth)), SkIntToScalar(SkTMin(maxDimension, pHeight))}; canvas->clipRect(rect); SkMSec start = SkTime::GetMSecs(); for (int x = 0; x < slices; ++x) { for (int y = 0; y < slices; ++y) { pic->draw(canvas); canvas->translate(0, SkIntToScalar(yInterval)); } canvas->translate(SkIntToScalar(xInterval), SkIntToScalar(-yInterval * slices)); } SkMSec end = SkTime::GetMSecs(); canvas->restore(); return end - start; } static void drawPict(SkPicture* pic, SkCanvas* canvas, int scale) { canvas->clear(SK_ColorWHITE); if (scale != 1) { canvas->save(); canvas->scale(1.0f / scale, 1.0f / scale); } pic->draw(canvas); if (scale != 1) { canvas->restore(); } } static void writePict(const SkBitmap& bitmap, const char* outDir, const char* pngName) { SkString outFile = make_filepath(0, outDir, pngName); if (!SkImageEncoder::EncodeFile(outFile.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100)) { SkDebugf("unable to encode gr %s (width=%d height=%d)\n", pngName, bitmap.width(), bitmap.height()); } } void TestResult::testOne() { SkPicture* pic = NULL; { #if DEBUG_SHOW_TEST_NAME if (fTestStep == kCompareBits) { SkString testName(fFilename); const char http[] = "http"; if (testName.startsWith(http)) { testName.remove(0, sizeof(http) - 1); } while (testName.startsWith("_")) { testName.remove(0, 1); } const char dotSkp[] = ".skp"; if (testName.endsWith(dotSkp)) { size_t len = testName.size(); testName.remove(len - (sizeof(dotSkp) - 1), sizeof(dotSkp) - 1); } testName.prepend("skp"); testName.append("1"); strncpy(DEBUG_FILENAME_STRING, testName.c_str(), DEBUG_FILENAME_STRING_LENGTH); } else if (fTestStep == kEncodeFiles) { strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH); } #endif SkString path = make_filepath(fDirNo, IN_DIR, fFilename); SkFILEStream stream(path.c_str()); if (!stream.isValid()) { SkDebugf("invalid stream %s\n", path.c_str()); goto finish; } pic = SkPicture::CreateFromStream(&stream, &SkImageDecoder::DecodeMemory); if (!pic) { SkDebugf("unable to decode %s\n", fFilename); goto finish; } int width = pic->width(); int height = pic->height(); SkBitmap oldBitmap, opBitmap; fScale = 1; while (width / fScale > 32767 || height / fScale > 32767) { ++fScale; } do { int dimX = (width + fScale - 1) / fScale; int dimY = (height + fScale - 1) / fScale; if (oldBitmap.allocN32Pixels(dimX, dimY) && opBitmap.allocN32Pixels(dimX, dimY)) { break; } SkDebugf("-%d-", fScale); } while (++fScale < 256); if (fScale >= 256) { SkDebugf("unable to allocate bitmap for %s (w=%d h=%d)\n", fFilename, width, height); goto finish; } oldBitmap.eraseColor(SK_ColorWHITE); SkCanvas oldCanvas(oldBitmap); oldCanvas.setAllowSimplifyClip(false); opBitmap.eraseColor(SK_ColorWHITE); SkCanvas opCanvas(opBitmap); opCanvas.setAllowSimplifyClip(true); drawPict(pic, &oldCanvas, fScale); drawPict(pic, &opCanvas, fScale); if (fTestStep == kCompareBits) { fPixelError = similarBits(oldBitmap, opBitmap); int oldTime = timePict(pic, &oldCanvas); int opTime = timePict(pic, &opCanvas); fTime = SkTMax(0, oldTime - opTime); } else if (fTestStep == kEncodeFiles) { SkString pngStr = make_png_name(fFilename); const char* pngName = pngStr.c_str(); writePict(oldBitmap, outOldDir, pngName); writePict(opBitmap, outOpDir, pngName); } } finish: if (pic) { pic->unref(); } } static SkString makeStatusString(int dirNo) { SkString statName; statName.printf("stats%d.txt", dirNo); SkString statusFile = make_filepath(0, outStatusDir, statName.c_str()); return statusFile; } class PreParser { public: PreParser(int dirNo, bool threaded) : fDirNo(dirNo) , fIndex(0) , fThreaded(threaded) { SkString statusPath = makeStatusString(dirNo); if (!sk_exists(statusPath.c_str())) { return; } SkFILEStream reader; reader.setPath(statusPath.c_str()); while (fetch(reader, &fResults.push_back())) ; fResults.pop_back(); } bool fetch(SkFILEStream& reader, TestResult* result) { char c; int i = 0; result->init(fDirNo); result->fPixelError = 0; result->fTime = 0; do { bool readOne = reader.read(&c, 1) != 0; if (!readOne) { // SkASSERT(i == 0); // the current text may be incomplete -- if so, ignore it return false; } if (c == ' ') { result->fFilename[i++] = '\0'; break; } result->fFilename[i++] = c; SkASSERT(i < kMaxLength); } while (true); do { if (!reader.read(&c, 1)) { return false; } if (c == ' ') { break; } SkASSERT(c >= '0' && c <= '9'); result->fPixelError = result->fPixelError * 10 + (c - '0'); } while (true); bool minus = false; do { if (!reader.read(&c, 1)) { return false; } if (c == '\n') { break; } if (c == '-') { minus = true; continue; } SkASSERT(c >= '0' && c <= '9'); result->fTime = result->fTime * 10 + (c - '0'); } while (true); if (minus) { result->fTime = -result->fTime; } return true; } bool match(const SkString& filename, SkFILEWStream* stream, TestResult* result) { if (fThreaded) { for (int index = 0; index < fResults.count(); ++index) { const TestResult& test = fResults[index]; if (filename.equals(test.fFilename)) { *result = test; SkString outStr(result->status()); stream->write(outStr.c_str(), outStr.size()); return true; } } } else if (fIndex < fResults.count()) { *result = fResults[fIndex++]; SkASSERT(filename.equals(result->fFilename)); SkString outStr(result->status()); stream->write(outStr.c_str(), outStr.size()); return true; } return false; } private: int fDirNo; int fIndex; SkTArray fResults; bool fThreaded; }; static bool doOneDir(TestState* state, bool threaded) { int dirNo = state->fResult.fDirNo; skiatest::Reporter* reporter = state->fReporter; SkString dirName = make_in_dir_name(dirNo); if (!dirName.size()) { return false; } SkOSFile::Iter iter(dirName.c_str(), "skp"); SkString filename; int testCount = 0; PreParser preParser(dirNo, threaded); SkFILEWStream statusStream(makeStatusString(dirNo).c_str()); while (iter.next(&filename)) { for (size_t index = 0; index < skipOverSeptCount; ++index) { if (skipOverSept[index].directory == dirNo && strcmp(filename.c_str(), skipOverSept[index].filename) == 0) { goto checkEarlyExit; } } if (preParser.match(filename, &statusStream, &state->fResult)) { (void) addError(state, state->fResult); ++testCount; goto checkEarlyExit; } { TestResult& result = state->fResult; result.test(dirNo, filename); SkString outStr(result.status()); statusStream.write(outStr.c_str(), outStr.size()); statusStream.flush(); if (addError(state, result)) { SkDebugf("%s", result.progress().c_str()); } } ++testCount; if (reporter->verbose()) { SkDebugf("."); if (++testCount % 100 == 0) { SkDebugf("%d\n", testCount); } } checkEarlyExit: if (0 && testCount >= 1) { return true; } } return true; } static bool initTest() { #if !defined SK_BUILD_FOR_WIN && !defined SK_BUILD_FOR_MAC SK_CONF_SET("images.jpeg.suppressDecoderWarnings", true); SK_CONF_SET("images.png.suppressDecoderWarnings", true); #endif return make_out_dirs(); } static bool initUberTest(int firstDirNo, int lastDirNo) { if (!initTest()) { return false; } for (int index = firstDirNo; index <= lastDirNo; ++index) { SkString statusDir(outStatusDir); statusDir.appendf("%d", index); if (!make_one_out_dir(statusDir.c_str())) { return false; } } return true; } static void testSkpClipEncode(TestState* data) { data->fResult.testOne(); if (data->fReporter->verbose()) { SkDebugf("+"); } } static void encodeFound(skiatest::Reporter* reporter, TestState& state) { if (reporter->verbose()) { if (state.fPixelWorst.count()) { SkTDArray worst; for (int index = 0; index < state.fPixelWorst.count(); ++index) { *worst.append() = &state.fPixelWorst[index]; } SkTQSort(worst.begin(), worst.end() - 1); for (int index = 0; index < state.fPixelWorst.count(); ++index) { const TestResult& result = *worst[index]; SkDebugf("%d %s pixelError=%d\n", result.fDirNo, result.fFilename, result.fPixelError); } } if (state.fSlowest.count()) { SkTDArray slowest; for (int index = 0; index < state.fSlowest.count(); ++index) { *slowest.append() = &state.fSlowest[index]; } if (slowest.count() > 0) { SkTQSort(slowest.begin(), slowest.end() - 1); for (int index = 0; index < slowest.count(); ++index) { const TestResult& result = *slowest[index]; SkDebugf("%d %s time=%d\n", result.fDirNo, result.fFilename, result.fTime); } } } } int threadCount = reporter->allowThreaded() ? SkThreadPool::kThreadPerCore : 1; TestRunner testRunner(reporter, threadCount); for (int index = 0; index < state.fPixelWorst.count(); ++index) { const TestResult& result = state.fPixelWorst[index]; SkString filename(result.fFilename); if (!filename.endsWith(".skp")) { filename.append(".skp"); } *testRunner.fRunnables.append() = SkNEW_ARGS(TestRunnableEncode, (&testSkpClipEncode, result.fDirNo, filename.c_str(), &testRunner)); } testRunner.render(); #if 0 for (int index = 0; index < state.fPixelWorst.count(); ++index) { const TestResult& result = state.fPixelWorst[index]; SkString filename(result.fFilename); if (!filename.endsWith(".skp")) { filename.append(".skp"); } TestResult::Test(result.fDirNo, filename.c_str(), kEncodeFiles); if (reporter->verbose()) SkDebugf("+"); } #endif } DEF_TEST(PathOpsSkpClip, reporter) { if (!initTest()) { return; } SkTArray errors; TestState state; state.init(0, reporter); for (int dirNo = 1; dirNo <= 100; ++dirNo) { if (reporter->verbose()) { SkDebugf("dirNo=%d\n", dirNo); } state.fResult.fDirNo = dirNo; if (!doOneDir(&state, false)) { break; } } encodeFound(reporter, state); } static void testSkpClipMain(TestState* data) { (void) doOneDir(data, true); } DEF_TEST(PathOpsSkpClipThreaded, reporter) { if (!initTest()) { return; } int threadCount = reporter->allowThreaded() ? SkThreadPool::kThreadPerCore : 1; TestRunner testRunner(reporter, threadCount); const int firstDirNo = 1; for (int dirNo = firstDirNo; dirNo <= 100; ++dirNo) { *testRunner.fRunnables.append() = SkNEW_ARGS(TestRunnableDir, (&testSkpClipMain, dirNo, &testRunner)); } testRunner.render(); TestState state; state.init(0, reporter); for (int dirNo = firstDirNo; dirNo <= 100; ++dirNo) { TestState& testState = testRunner.fRunnables[dirNo - 1]->fState; SkASSERT(testState.fResult.fDirNo == dirNo); for (int inner = 0; inner < testState.fPixelWorst.count(); ++inner) { addError(&state, testState.fPixelWorst[inner]); } for (int inner = 0; inner < testState.fSlowest.count(); ++inner) { addError(&state, testState.fSlowest[inner]); } } encodeFound(reporter, state); } static void testSkpClipUber(TestState* data) { data->fResult.testOne(); SkString dirName = make_stat_dir_name(data->fResult.fDirNo); if (!dirName.size()) { return; } SkString statName(data->fResult.fFilename); SkASSERT(statName.endsWith(".skp")); statName.remove(statName.size() - 4, 4); statName.appendf(".%d.%d.skp", data->fResult.fPixelError, data->fResult.fTime); SkString statusFile = make_filepath(data->fResult.fDirNo, outStatusDir, statName.c_str()); SkFILE* file = sk_fopen(statusFile.c_str(), kWrite_SkFILE_Flag); if (!file) { SkDebugf("failed to create %s", statusFile.c_str()); return; } sk_fclose(file); if (data->fReporter->verbose()) { if (data->fResult.fPixelError || data->fResult.fTime) { SkDebugf("%s", data->fResult.progress().c_str()); } else { SkDebugf("."); } } } static bool buildTests(skiatest::Reporter* reporter, int firstDirNo, int lastDirNo, SkTDArray* tests, SkTDArray* sorted) { for (int dirNo = firstDirNo; dirNo <= lastDirNo; ++dirNo) { SkString dirName = make_stat_dir_name(dirNo); if (!dirName.size()) { return false; } SkOSFile::Iter iter(dirName.c_str(), "skp"); SkString filename; while (iter.next(&filename)) { TestResult test; test.init(dirNo); SkString spaceFile(filename); char* spaces = spaceFile.writable_str(); int spaceSize = (int) spaceFile.size(); for (int index = 0; index < spaceSize; ++index) { if (spaces[index] == '.') { spaces[index] = ' '; } } int success = sscanf(spaces, "%s %d %d skp", test.fFilename, &test.fPixelError, &test.fTime); if (success < 3) { SkDebugf("failed to scan %s matched=%d\n", filename.c_str(), success); return false; } *tests[dirNo - firstDirNo].append() = test; } if (!sorted) { continue; } SkTDArray& testSet = tests[dirNo - firstDirNo]; int count = testSet.count(); for (int index = 0; index < count; ++index) { *sorted[dirNo - firstDirNo].append() = (SortByName*) &testSet[index]; } if (sorted[dirNo - firstDirNo].count()) { SkTQSort(sorted[dirNo - firstDirNo].begin(), sorted[dirNo - firstDirNo].end() - 1); if (reporter->verbose()) { SkDebugf("+"); } } } return true; } bool Less(const SortByName& a, const SortByName& b); bool Less(const SortByName& a, const SortByName& b) { return a < b; } DEF_TEST(PathOpsSkpClipUberThreaded, reporter) { const int firstDirNo = 1; const int lastDirNo = 100; if (!initUberTest(firstDirNo, lastDirNo)) { return; } const int dirCount = lastDirNo - firstDirNo + 1; SkTDArray tests[dirCount]; SkTDArray sorted[dirCount]; if (!buildTests(reporter, firstDirNo, lastDirNo, tests, sorted)) { return; } int threadCount = reporter->allowThreaded() ? SkThreadPool::kThreadPerCore : 1; TestRunner testRunner(reporter, threadCount); for (int dirNo = firstDirNo; dirNo <= lastDirNo; ++dirNo) { SkString dirName = make_in_dir_name(dirNo); if (!dirName.size()) { continue; } SkOSFile::Iter iter(dirName.c_str(), "skp"); SkString filename; while (iter.next(&filename)) { int count; SortByName name; for (size_t index = 0; index < skipOverSeptCount; ++index) { if (skipOverSept[index].directory == dirNo && strcmp(filename.c_str(), skipOverSept[index].filename) == 0) { goto checkEarlyExit; } } name.init(dirNo); strncpy(name.fFilename, filename.c_str(), filename.size() - 4); // drop .skp count = sorted[dirNo - firstDirNo].count(); if (SkTSearch(sorted[dirNo - firstDirNo].begin(), count, &name, sizeof(&name)) < 0) { *testRunner.fRunnables.append() = SkNEW_ARGS(TestRunnableFile, (&testSkpClipUber, dirNo, filename.c_str(), &testRunner)); } checkEarlyExit: ; } } testRunner.render(); SkTDArray results[dirCount]; if (!buildTests(reporter, firstDirNo, lastDirNo, results, NULL)) { return; } SkTDArray allResults; for (int dirNo = firstDirNo; dirNo <= lastDirNo; ++dirNo) { SkTDArray& array = results[dirNo - firstDirNo]; allResults.append(array.count(), array.begin()); } int allCount = allResults.count(); SkTDArray pixels; SkTDArray times; for (int index = 0; index < allCount; ++index) { *pixels.append() = (SortByPixel*) &allResults[index]; *times.append() = (SortByTime*) &allResults[index]; } TestState state; if (pixels.count()) { SkTQSort(pixels.begin(), pixels.end() - 1); for (int inner = 0; inner < kMaxFiles; ++inner) { *state.fPixelWorst.append() = *pixels[allCount - inner - 1]; } } if (times.count()) { SkTQSort(times.begin(), times.end() - 1); for (int inner = 0; inner < kMaxFiles; ++inner) { *state.fSlowest.append() = *times[allCount - inner - 1]; } } encodeFound(reporter, state); } DEF_TEST(PathOpsSkpClipOneOff, reporter) { if (!initTest()) { return; } const int testIndex = 43 - 37; int dirNo = skipOverSept[testIndex].directory; SkAssertResult(make_in_dir_name(dirNo).size()); SkString filename(skipOverSept[testIndex].filename); TestResult state; state.test(dirNo, filename); if (reporter->verbose()) { SkDebugf("%s", state.status().c_str()); } state.fTestStep = kEncodeFiles; state.testOne(); }