diff options
| author | Simon Hausmann <simon.hausmann@digia.com> | 2012-11-22 09:09:45 +0100 |
|---|---|---|
| committer | Simon Hausmann <simon.hausmann@digia.com> | 2012-11-22 09:10:13 +0100 |
| commit | 470286ecfe79d59df14944e5b5d34630fc739391 (patch) | |
| tree | 43983212872e06cebefd2ae474418fa2908ca54c /Tools | |
| parent | 23037105e948c2065da5a937d3a2396b0ff45c1e (diff) | |
| download | qtwebkit-470286ecfe79d59df14944e5b5d34630fc739391.tar.gz | |
Imported WebKit commit e89504fa9195b2063b2530961d4b73dd08de3242 (http://svn.webkit.org/repository/webkit/trunk@135485)
Change-Id: I03774e5ac79721c13ffa30d152537a74d0b12e66
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
Diffstat (limited to 'Tools')
251 files changed, 8397 insertions, 3561 deletions
diff --git a/Tools/BuildSlaveSupport/build.webkit.org-config/mastercfg_unittest.py b/Tools/BuildSlaveSupport/build.webkit.org-config/mastercfg_unittest.py index d1614c0e0..ae21e237e 100755 --- a/Tools/BuildSlaveSupport/build.webkit.org-config/mastercfg_unittest.py +++ b/Tools/BuildSlaveSupport/build.webkit.org-config/mastercfg_unittest.py @@ -61,7 +61,7 @@ class MasterCfgTest(unittest.TestCase): '1 unique leaks found!', ] run_webkit_tests._parseNewRunWebKitTestsOutput(log_text) - self.assertEquals(run_webkit_tests.incorrectLayoutLines, expected_incorrect_lines) + self.assertEqual(run_webkit_tests.incorrectLayoutLines, expected_incorrect_lines) class StubStdio(object): @@ -354,7 +354,7 @@ class SVNMirrorTest(unittest.TestCase): for buildStepFactory, kwargs in builder['factory'].steps: if str(buildStepFactory).split('.')[-1] == 'CheckOutSource': CheckOutSourceInstance = buildStepFactory(**kwargs) - self.assertEquals(CheckOutSourceInstance.baseURL, self.get_SVNMirrorFromConfig(builder['name'])) + self.assertEqual(CheckOutSourceInstance.baseURL, self.get_SVNMirrorFromConfig(builder['name'])) class BuildStepsConstructorTest(unittest.TestCase): diff --git a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/garden-o-matic.html b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/garden-o-matic.html index 19e156bda..24b06073c 100644 --- a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/garden-o-matic.html +++ b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/garden-o-matic.html @@ -32,10 +32,10 @@ James, a web developer from Birmingham, UK. script-src 'self' file: https://ajax.googleapis.com; style-src 'self' 'unsafe-inline' file: https://ajax.googleapis.com http://fonts.googleapis.com; font-src http://themes.googleusercontent.com; - img-src 'self' https://ajax.googleapis.com http://build.chromium.org http://build.webkit.org file: http://127.0.0.1:8127; - media-src http://build.chromium.org http://build.webkit.org http://127.0.0.1:8127; - frame-src http://build.chromium.org http://build.webkit.org http://test-results.appspot.com http://127.0.0.1:8127; - connect-src http://trac.webkit.org http://build.chromium.org http://build.webkit.org http://127.0.0.1:8127"> + img-src 'self' https://ajax.googleapis.com http://build.chromium.org http://build.webkit.org; + media-src 'self' http://build.chromium.org http://build.webkit.org; + frame-src 'self' http://build.chromium.org http://build.webkit.org http://test-results.appspot.com; + connect-src 'self' http://trac.webkit.org http://build.chromium.org http://build.webkit.org"> <title>Garden-O-Matic</title> <link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Open+Sans:400,700"> <link rel="stylesheet" href="https://ajax.googleapis.com/ajax/libs/jqueryui/1.8.15/themes/base/jquery-ui.css"> diff --git a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/checkout.js b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/checkout.js index 862ce6519..10ea1ec53 100644 --- a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/checkout.js +++ b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/checkout.js @@ -56,7 +56,7 @@ checkout.subversionURLForTest = function(testName) checkout.isAvailable = function(callback) { net.ajax({ - url: config.kLocalServerURL + '/ping', + url: '/ping', success: function() { callback(true); }, @@ -69,7 +69,7 @@ checkout.isAvailable = function(callback) checkout.rollout = function(revision, reason, callback, checkoutUnavailable) { callIfCheckoutAvailable(function() { - net.post(config.kLocalServerURL + '/rollout?' + $.param({ + net.post('/rollout?' + $.param({ 'revision': revision, 'reason': reason }), function() { @@ -88,7 +88,7 @@ checkout.rebaseline = function(failureInfoList, callback, progressCallback, chec tests[failureInfo.testName][failureInfo.builderName] = base.uniquifyArray(base.flattenArray(failureInfo.failureTypeList.map(results.failureTypeToExtensionList))); } - net.post(config.kLocalServerURL + '/rebaselineall', JSON.stringify(tests), function() { callback() }); + net.post('/rebaselineall', JSON.stringify(tests), function() { callback() }); }, checkoutUnavailable); }; diff --git a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/checkout_unittests.js b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/checkout_unittests.js index 32a567407..6d65ba232 100644 --- a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/checkout_unittests.js +++ b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/checkout_unittests.js @@ -76,7 +76,7 @@ test("rebaseline", 3, function() { }); deepEqual(requests, [ - ["http://127.0.0.1:8127/rebaselineall", + ["/rebaselineall", JSON.stringify({ "another/test.svg": { "WebKit Linux": ["png"], diff --git a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/config.js b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/config.js index 9600021f7..8fdc92372 100644 --- a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/config.js +++ b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/config.js @@ -169,7 +169,6 @@ config.kPlatforms = { config.kTracURL = 'http://trac.webkit.org'; config.kBugzillaURL = 'https://bugs.webkit.org'; -config.kLocalServerURL = 'http://127.0.0.1:8127'; config.kRevisionAttr = 'data-revision'; config.kTestNameAttr = 'data-test-name'; diff --git a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/controllers.js b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/controllers.js index 3dacd28e8..f2d0a2fb1 100644 --- a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/controllers.js +++ b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/controllers.js @@ -42,7 +42,7 @@ function rebaselineWithStatusUpdates(failureInfoList) statusView.addMessage(id, 'Performing rebaseline of ' + testName + '...'); checkout.rebaseline(failureInfoList, function() { - statusView.addFinalMessage(id, 'Rebaseline done! Please land with "webkit-patch land-cowboy".'); + statusView.addFinalMessage(id, 'Rebaseline done! Please land with "webkit-patch land-cowhand".'); }, function(failureInfo) { statusView.addMessage(id, failureInfo.testName + ' on ' + ui.displayNameForBuilder(failureInfo.builderName)); }, function() { @@ -61,7 +61,7 @@ function updateExpectationsWithStatusUpdates(failureInfoList) statusView.addMessage(id, 'Updating expectations of ' + testName + '...'); checkout.updateExpectations(failureInfoList, function() { - statusView.addFinalMessage(id, 'Expectations update done! Please land with "webkit-patch land-cowboy".'); + statusView.addFinalMessage(id, 'Expectations update done! Please land with "webkit-patch land-cowhand".'); }, function() { statusView.addFinalMessage(id, kCheckoutUnavailableMessage); }); diff --git a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/results.js b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/results.js index 012df032a..2dd55a838 100644 --- a/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/results.js +++ b/Tools/BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/results.js @@ -188,7 +188,7 @@ results.directoryForBuilder = function(builderName) function resultsDirectoryURL(platform, builderName) { if (config.useLocalResults) - return config.kLocalServerURL + '/localresult?path='; + return '/localresult?path='; return resultsDirectoryListingURL(platform, builderName) + 'results/layout-test-results/'; } diff --git a/Tools/ChangeLog b/Tools/ChangeLog index 693ae644b..fbacc95f3 100644 --- a/Tools/ChangeLog +++ b/Tools/ChangeLog @@ -1,3 +1,2632 @@ +2012-11-21 Zan Dobersek <zandobersek@gmail.com> + + [GTK][WTR] Implement AccessibilityUIElement::stringValue + https://bugs.webkit.org/show_bug.cgi?id=102951 + + Reviewed by Martin Robinson. + + Implement AccessibilityUIElement::stringValue in the ATK backend + in the same manner it is implemented in DumpRenderTree. + + * WebKitTestRunner/InjectedBundle/atk/AccessibilityUIElementAtk.cpp: + (WTR::replaceCharactersForResults): + (WTR): + (WTR::AccessibilityUIElement::stringValue): + +2012-11-21 Vineet Chaudhary <rgf748@motorola.com> + + Unreviewed. Adding myself to committers.py. + + * Scripts/webkitpy/common/config/committers.py: + +2012-11-21 Tien-Ren Chen <trchen@chromium.org> + + [chromium] Device scale factor should be no-op when applyDeviceScaleFactorInCompositor == 0 + https://bugs.webkit.org/show_bug.cgi?id=100061 + + Reviewed by Adam Barth. + + On Android we're using a different pixel scaling implementation + (WebCore::Settings::applyDefaultDeviceScaleFactorInCompositor() == 0) than other + platforms. In this mode, we don't make use of device-independent pixels. Device + scale factor is provided to WebKit and get merged into page scale factor. Other + than that device scale factor should have no effects on rendering. + + * DumpRenderTree/chromium/WebPreferences.cpp: + (WebPreferences::applyTo): + +2012-11-21 Fady Samuel <fsamuel@chromium.org> + + Clear MousePressed state on context menu to avoid initiating a drag + https://bugs.webkit.org/show_bug.cgi?id=101786 + + Reviewed by Ojan Vafai. + + * DumpRenderTree/chromium/TestRunner/src/EventSender.cpp: + (WebTestRunner): + (WebTestRunner::EventSender::EventSender): + (WebTestRunner::EventSender::contextClick): + Only send a MouseUp on Windows. Keep the current mouse pressed state when + calling up a context menu. + +2012-11-21 Thiago Marcos P. Santos <thiago.santos@intel.com> + + [EFL] KURL unit test crashing when tiled backing store is enabled on Release Bots + https://bugs.webkit.org/show_bug.cgi?id=102895 + + Reviewed by Gyuyoung Kim. + + Change the link order so it wont override the new operator on gtest. + Looks like it was crashing because an allocator mismatch (using libc's + new and later fastMalloc delete. Thanks to Kangil Han for hinting on + the fastMalloc issue. + + * TestWebKitAPI/CMakeLists.txt: + +2012-11-21 Kentaro Hara <haraken@chromium.org> + + Unreviewed, rolling out r135340. + http://trac.webkit.org/changeset/135340 + https://bugs.webkit.org/show_bug.cgi?id=102492 + + It broke Safari's internal build + + * WebKitTestRunner/InjectedBundle/Bindings/CodeGeneratorTestRunner.pm: + (new): + (GenerateModule): + (GenerateInterface): + (finish): + +2012-11-21 Yael Aharon <yael.aharon@intel.com>, Gyuyoung Kim <gyuyoung.kim@samsung.com> + + [EFL] Turn on WTF_USE_TILED_BACKING_STORE by default + https://bugs.webkit.org/show_bug.cgi?id=101526 + + Reviewed by Kenneth Rohde Christiansen. + + Turn on WTF_USE_TILED_BACKING_STORE for EFL port. + + * Scripts/webkitperl/FeatureList.pm: + * TestWebKitAPI/CMakeLists.txt: No include KURL.cpp because of API test crash. + +2012-11-21 Jongseok Yang <js45.yang@samsung.com> + + [EFL][WK2] Rename ewk_view_setting_encoding_custom_XXX to ewk_view_custom_encoding_XXX + https://bugs.webkit.org/show_bug.cgi?id=102867 + + Reviewed by Gyuyoung Kim. + + Rename ewk_view_setting_encoding_custom_XXX to ewk_view_custom_encoding_XXX. + + ewk_view_setting_encoding_custom_XXX APIs might be misunderstanded as the "setting" word + because ewk_view_setting_encoding_custom_set triggers the "reload" operation. + And ewk_view_setting_XXX is not correct because there is ewk_settings object for settings. + + * MiniBrowser/efl/main.c: + (on_key_down): + +2012-11-20 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed, rolling out r133859. + http://trac.webkit.org/changeset/133859 + https://bugs.webkit.org/show_bug.cgi?id=102875 + + This patch makes API test broken (Requested by gyuyoung on + #webkit). + + * Scripts/webkitperl/FeatureList.pm: + +2012-11-20 Jinwoo Song <jinwoo7.song@samsung.com> + + [EFL][WK2] Add Ewk_Window_Features API and related UI callbacks + https://bugs.webkit.org/show_bug.cgi?id=99114 + + Reviewed by Gyuyoung Kim. + + Implemented window_create and window_close smartcallback functions. + + * MiniBrowser/efl/main.c: + (on_window_create): + (on_window_close): + (window_create): + +2012-11-20 Ojan Vafai <ojan@chromium.org> + + Simplify builder filters now that we have lists of which builders run which tests + https://bugs.webkit.org/show_bug.cgi?id=102849 + + Reviewed by Dirk Pranke. + + We only need filters when we load the same master for multiple groups in the + same test type, i.e. when we need to only include some of the builders that run + a given test suite on a given master. + + Also, get rid of the DEFAULT_BUILDER enum. We were always using the first builder anyways. + Now just make it a method on BuilderGroup. + + * TestResultServer/static-dashboards/builders.js: + (BuilderGroup.prototype.append): + (BuilderGroup.prototype.setup): + (BuilderGroup.prototype._defaultBuilder): + (BuilderGroup.prototype.master): + (requestBuilderList): + (isChromiumWebkitTipOfTreeTestRunner): + (isChromiumWebkitDepsTestRunner): + (loadBuildersList): + * TestResultServer/static-dashboards/flakiness_dashboard_unittests.js: + (test): + +2012-11-20 Ojan Vafai <ojan@chromium.org> + + Remove perfav master for webkit_unit_tests and test_shell_tests. + There are no bots on this master that run these tests. + * TestResultServer/static-dashboards/builders.js: + +2012-11-20 Ojan Vafai <ojan@chromium.org> + + Remove special case for layout tests when builders fail to load + https://bugs.webkit.org/show_bug.cgi?id=102842 + + Reviewed by Tony Chang. + + Now that we load only builders that actually run the given test + type, we can reliably show errors to the users because it + represents a broken bot. + * TestResultServer/static-dashboards/loader.js: + +2012-11-15 Ojan Vafai <ojan@chromium.org> + + Generate a list of builders/test suites from the buildbot json + https://bugs.webkit.org/show_bug.cgi?id=102443 + + Reviewed by Dirk Pranke. + + Instead of the cludgy things we do now to track which bots run which tests, + we generate all that data from the buildbots' json files. + This is the minimal amount to keep everything working. Once this lands, + we can also do a bunch of followup cleanup. + + For now we commit the generated data. In theory, in the future, we could + have the test results server generate the data on the fly. + + For the sake of easily understanding what changes when we run the generate script, + also checkin a pretty printed version of the output. The pretty printed version + is too large to serve as part of the flakiness dashboard though. + + This also has the benefit of making the dashboard load much faster since + we no longer ever need to block on requests to buildbot. + + * TestResultServer/generate_builders_json.py: Added. + (master_json_url): + (builder_json_url): + (cached_build_json_url): + (fetch_json): + (insert_builder_and_test_data): + (main): + * TestResultServer/generate_builders_json_unittest.py: Added. + (GenerateBuildersJsonTest): + (GenerateBuildersJsonTest.test_master_json_url): + (GenerateBuildersJsonTest.test_builder_json_url): + (GenerateBuildersJsonTest.test_cached_build_json_url): + (GenerateBuildersJsonTest.test_generate_json_data): + (GenerateBuildersJsonTest.test_generate_json_data.dummy_fetch_json): + * TestResultServer/static-dashboards/builders-pretty.jsonp: Added. + * TestResultServer/static-dashboards/builders.js: + (LOAD_BUILDBOT_DATA): + (BuilderGroup): + (BuilderGroup.prototype.append): + (BuilderGroup.prototype.master): + (requestBuilderList): + * TestResultServer/static-dashboards/builders.jsonp: Added. + * TestResultServer/static-dashboards/builders_unittests.js: Added. + * TestResultServer/static-dashboards/dashboard_base.js: + * TestResultServer/static-dashboards/flakiness_dashboard.js: + (showPopupForBuild): + (htmlForTestResults): + (htmlForIndividualTestOnAllBuildersWithResultsLinks): + (loadExpectationsLayoutTests): + * TestResultServer/static-dashboards/flakiness_dashboard_unittests.js: + (resetGlobals): + (test): + * TestResultServer/static-dashboards/loader.js: + * TestResultServer/static-dashboards/loader_unittests.js: + * TestResultServer/static-dashboards/run-embedded-unittests.html: + * TestResultServer/static-dashboards/run-unittests.html: + * TestResultServer/static-dashboards/timeline_explorer.html: + +2012-11-20 Thiago Marcos P. Santos <thiago.santos@intel.com> + + [WTR][Qt] Enable fixedLayout when needed by the test + https://bugs.webkit.org/show_bug.cgi?id=102811 + + Reviewed by Kenneth Rohde Christiansen. + + Create a flickable view for CSS Device Adaptation tests. This is + crucial for testing them since they will change the size of the + viewport. + + * WebKitTestRunner/PlatformWebView.h: + (PlatformWebView): + * WebKitTestRunner/qt/PlatformWebViewQt.cpp: + (WTR::PlatformWebView::PlatformWebView): + (WTR::PlatformWebView::viewSupportsOptions): + (WTR): + * WebKitTestRunner/qt/main.cpp: + (main): + +2012-11-20 Thiago Marcos P. Santos <thiago.santos@intel.com> + + [WTR] WebKitTestRunner should be able to run tests using fixed layout + https://bugs.webkit.org/show_bug.cgi?id=102517 + + Reviewed by Kenneth Rohde Christiansen. + + WTR will now request the creation of a view that has a page using + fixed layout for CSS Device Adaptation tests, but this feature might + be used in the future by any other test that requires a mobile-like type + of viewport (i.e. Viewport META tests should be ported). + + The viewport type of the other tests remains unchanged and is restored + when the runner leaves the device-adapt/ folder. + + * WebKitTestRunner/PlatformWebView.h: + (PlatformWebView): + * WebKitTestRunner/TestInvocation.cpp: + (WTR): + (WTR::shouldUseFixedLayout): + (WTR::updateLayoutType): + (WTR::TestInvocation::invoke): + * WebKitTestRunner/efl/PlatformWebViewEfl.cpp: + (WTR::PlatformWebView::PlatformWebView): + (WTR::PlatformWebView::viewSupportsOptions): + (WTR): + +2012-11-20 Csaba Osztrogonác <ossy@webkit.org> + + [Qt] REGRESSION(r128174): Fast build path doesn't work now + https://bugs.webkit.org/show_bug.cgi?id=100360 + + Reviewed by Tor Arne Vestbø. + + Use a separated .builtRevisions.cache file instead of .qmake.cache to cache built SVN revisions. + + * Scripts/webkitdirs.pm: + (buildQMakeProjects): + +2012-11-20 Mateusz Leszko <m.leszko@samsung.com> + + [EFL][GTK]Sharing accessibility support in WebKitTestRunner. + https://bugs.webkit.org/show_bug.cgi?id=99011 + + Reviewed by Martin Robinson. + + Accessibility files from gtk folder are moved to atk folder due to common implementation. Event Type naming changed to default, from Gtk to ATK. + + * WebKitTestRunner/InjectedBundle/atk/AccessibilityControllerAtk.cpp: Renamed from Tools/WebKitTestRunner/InjectedBundle/gtk/AccessibilityControllerGtk.cpp. + (WTR::AccessibilityController::logAccessibilityEvents): + * WebKitTestRunner/InjectedBundle/atk/AccessibilityUIElementAtk.cpp: Renamed from Tools/WebKitTestRunner/InjectedBundle/gtk/AccessibilityUIElementGtk.cpp. + +2012-11-20 Zan Dobersek <zandobersek@gmail.com> + + webkitpy unit tests should run serially when checking code coverage + https://bugs.webkit.org/show_bug.cgi?id=102693 + + Reviewed by Dirk Pranke. + + When checking code coverage, the unit tests should not be run in parallel + as this causes the tracing functions (set via sys.settrace in the coverage + module) being overriden, resulting in incorrect coverage reports. + + * Scripts/webkitpy/test/main.py: + (Tester._run_tests): + +2012-11-19 Viatcheslav Ostapenko <v.ostapenko@samsung.com> + + [EFL] Add fallback for WebkitTestRunner if opengl is not available. + https://bugs.webkit.org/show_bug.cgi?id=102704 + + Reviewed by Laszlo Gombos. + + Add fallback to non-opengl evas engine in WebkitTestRunner if opengl is not available. + + * WebKitTestRunner/efl/PlatformWebViewEfl.cpp: + (WTR::initEcoreEvas): + +2012-11-19 Dimitri Glazkov <dglazkov@chromium.org> + + [garden-o-matic] Switch frontend to use the gardeningserver. + https://bugs.webkit.org/show_bug.cgi?id=102712 + + Reviewed by Dirk Pranke. + + Instead of serving garden-o-matic frontend as file, we now serve it from the gardening server. This enables + using garden-o-matic in a Chrome OS device, with a separate machine as a headless server. + + * BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/garden-o-matic.html: Changed CSP policy to use 'self'. + * BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/checkout.js: Removed now-unnecessary references to kLocalServerURL. + * BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/checkout_unittests.js: Tweaked the test expectation. + * BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/config.js: Removed kLocalServerURL. + * BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/controllers.js: Spuriously updated the name of the webkit-patch command. + * BuildSlaveSupport/build.webkit.org-config/public_html/TestFailures/scripts/results.js: Removed kLocalServerURL. + * Scripts/webkitpy/tool/servers/gardeningserver.py: Changed to use the new launch URL. + +2012-11-19 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed, rolling out r135172. + http://trac.webkit.org/changeset/135172 + https://bugs.webkit.org/show_bug.cgi?id=102710 + + Broke some WebKit2 api tests :( (Requested by japhet on + #webkit). + + * DumpRenderTree/chromium/WebViewHost.cpp: + (WebViewHost::updateForCommittedLoad): + +2012-11-19 Dimitri Glazkov <dglazkov@chromium.org> + + [garden-o-matic] Enable serving garden-o-matic with gardeningserver. + https://bugs.webkit.org/show_bug.cgi?id=102703 + + Reviewed by Ojan Vafai. + + To enable gardening from a Chrome OS device, we need the ability to serve garden-o-matic + from the same origin as the gardening server. This change gently massages the current + logic to adapt an extension-sniffing-based approach of identifying static files, + rather than requiring an explicit list. + + * Scripts/webkitpy/tool/servers/reflectionhandler.py: + (ReflectionHandler): Replaced STATIC_FILE_NAMES with STATIC_FILE_EXTENSIONS. + (ReflectionHandler._handle_request): Changed the logic to smell for extensions, rather than specific files. + * Scripts/webkitpy/tool/servers/reflectionhandler_unittest.py: Added. + +2012-11-19 Ojan Vafai <ojan@chromium.org> + + Add DOM and HTML watchlists and add myself to a bunch of lists + https://bugs.webkit.org/show_bug.cgi?id=102707 + + Reviewed by Eric Seidel. + + * Scripts/webkitpy/common/config/watchlist: + +2012-11-19 Jochen Eisinger <jochen@chromium.org> + + [chromium] move methods that only use the WebKit API from DRTTestRunner to TestRunner + https://bugs.webkit.org/show_bug.cgi?id=102676 + + Reviewed by Tony Chang. + + In addition, I've replaced parsePageNumber with the more commonly used + cppVariantToInt32, moved abortModal to the list of stubbed out methods, + and removed setAutomaticLinkDetectionEnabled which wasn't used + anywhere. + + * DumpRenderTree/chromium/DRTTestRunner.cpp: + (DRTTestRunner::DRTTestRunner): + (DRTTestRunner::reset): + (DRTTestRunner::overridePreference): + * DumpRenderTree/chromium/DRTTestRunner.h: + (DRTTestRunner): + * DumpRenderTree/chromium/TestRunner/src/TestRunner.cpp: + (WebTestRunner::TestRunner::TestRunner): + (WebTestRunner::TestRunner::reset): + (WebTestRunner): + (WebTestRunner::TestRunner::setTabKeyCyclesThroughElements): + (WebTestRunner::TestRunner::setAsynchronousSpellCheckingEnabled): + (WebTestRunner::TestRunner::execCommand): + (WebTestRunner::TestRunner::isCommandEnabled): + (WebTestRunner::TestRunner::pauseAnimationAtTimeOnElementWithId): + (WebTestRunner::TestRunner::pauseTransitionAtTimeOnElementWithId): + (WebTestRunner::TestRunner::elementDoesAutoCompleteForElementWithId): + (WebTestRunner::TestRunner::numberOfActiveAnimations): + (WebTestRunner::TestRunner::callShouldCloseOnWebView): + (WebTestRunner::TestRunner::setDomainRelaxationForbiddenForURLScheme): + (WebTestRunner::TestRunner::evaluateScriptInIsolatedWorldAndReturnValue): + (WebTestRunner::TestRunner::evaluateScriptInIsolatedWorld): + (WebTestRunner::TestRunner::setIsolatedWorldSecurityOrigin): + (WebTestRunner::TestRunner::setIsolatedWorldContentSecurityPolicy): + (WebTestRunner::TestRunner::addOriginAccessWhitelistEntry): + (WebTestRunner::TestRunner::removeOriginAccessWhitelistEntry): + (WebTestRunner::TestRunner::hasCustomPageSizeStyle): + (WebTestRunner::TestRunner::forceRedSelectionColors): + (WebTestRunner::TestRunner::addUserScript): + (WebTestRunner::TestRunner::addUserStyleSheet): + (WebTestRunner::TestRunner::startSpeechInput): + (WebTestRunner::TestRunner::loseCompositorContext): + (WebTestRunner::TestRunner::markerTextForListItem): + (WebTestRunner::TestRunner::findString): + (WebTestRunner::TestRunner::setMinimumTimerInterval): + (WebTestRunner::TestRunner::setAutofilled): + (WebTestRunner::TestRunner::setValueForUser): + (WebTestRunner::TestRunner::enableFixedLayoutMode): + (WebTestRunner::TestRunner::setFixedLayoutSize): + (WebTestRunner::TestRunner::selectionAsMarkup): + (WebTestRunner::TestRunner::setTextSubpixelPositioning): + (WebTestRunner::TestRunner::resetPageVisibility): + (WebTestRunner::TestRunner::setPageVisibility): + (WebTestRunner::TestRunner::setTextDirection): + (WebTestRunner::TestRunner::textSurroundingNode): + (WebTestRunner::TestRunner::workerThreadCount): + (WebTestRunner::TestRunner::cppVariantToBool): + (WebTestRunner::TestRunner::cppVariantToInt32): + (WebTestRunner::TestRunner::cppVariantToWebString): + (WebTestRunner::TestRunner::cppVariantToWebStringArray): + (WebTestRunner::TestRunner::printErrorMessage): formerly logErrorToConsole + (WebTestRunner::TestRunner::fallbackMethod): + * DumpRenderTree/chromium/TestRunner/src/TestRunner.h: + (WebKit): + (WebTestRunner::TestRunner::setWebView): + (TestRunner): + * DumpRenderTree/chromium/TestShell.cpp: + (TestShell::createMainWindow): + (TestShell::~TestShell): + +2012-11-19 Yusuke Sato <yusukes@chromium.org> + + [Chromium] Flash cannot receive scroll events when threaded compositing is in use + https://bugs.webkit.org/show_bug.cgi?id=101423 + + Reviewed by James Robinson. + + Call setWantsWheelEvents(true) in initialize() so that gesture-events and transformed-events tests in + LayoutTests/platform/chromium/plugins/ will not fail even if a buildbot introduces threaded compositing + in the future. + + * DumpRenderTree/chromium/TestWebPlugin.cpp: + (TestWebPlugin::initialize): + +2012-11-19 Nate Chapin <japhet@chromium.org> + + Move empty loading to DocumentLoader, simplify FrameLoader::init() + https://bugs.webkit.org/show_bug.cgi?id=101512 + + Reviewed by Adam Barth. + + Chromium DRT has some code that doesn't play nicely with empty urls and incorrectly + interprets them as a non-empty load. This ensures + http/tests/navigation/new-window-redirect-history.html continues to pass + in chromium. + + * DumpRenderTree/chromium/WebViewHost.cpp: + (WebViewHost::updateForCommittedLoad): + +2012-11-19 Vincent Scheib <scheib@chromium.org> + + [Chromium] Remove WebKit::WebRuntimeFeatures::enablePointerLock. + https://bugs.webkit.org/show_bug.cgi?id=96946 + + Reviewed by Adam Barth. + + The runtime flag functionality has already been removed. + Now that Chromium no longer has a compile dependency on this + API, it can be removed as well. + + * DumpRenderTree/chromium/TestShell.cpp: + (TestShell::TestShell): + +2012-11-19 Kihong Kwon <kihong.kwon@samsung.com> + + Add PROXIMITY_EVENTS feature + https://bugs.webkit.org/show_bug.cgi?id=102658 + + Reviewed by Kentaro Hara. + + Add PROXIMITY_EVENTS feature to FeatureList and qmake. + + * Scripts/webkitperl/FeatureList.pm: + * qmake/mkspecs/features/features.pri: + +2012-11-19 Christophe Dumez <christophe.dumez@intel.com> + + [WK2][WTR] Memory leak in TestController::initialize() + https://bugs.webkit.org/show_bug.cgi?id=102616 + + Reviewed by Kenneth Rohde Christiansen. + + Remove call to WKStringCreateWithUTF8CString() to construct + the icon database path which was leaking memory since the + returned WKStringRef was not adopted. The code now uses + WTF::String instead of std::string and converts it to a + WKStringRef using toWK(). + + * WebKitTestRunner/StringFunctions.h: + (WTR::toWK): Overload toWK() to take a WTF::String in + argument. + (WTR): + * WebKitTestRunner/TestController.cpp: + (WTR::TestController::initialize): + +2012-11-19 Kentaro Hara <haraken@chromium.org> + + Remove IDLStructure.pm + https://bugs.webkit.org/show_bug.cgi?id=102642 + + Reviewed by Adam Barth. + + Previously IDLStructure.pm was full of regular expressions to + parse IDL files. Now a new IDL parser is implemented, IDLStructure.pm + just contains several data structures for the IDL parser. We can + move them to IDLParser.pm and thus remove IDLStructure.pm. + + No tests. No change in generated code. + + * WebKitTestRunner/DerivedSources.make: + * WebKitTestRunner/GNUmakefile.am: + * WebKitTestRunner/InjectedBundle/DerivedSources.pri: + +2012-11-18 KyungTae Kim <ktf.kim@samsung.com> + + [EFL] Not to include "ewk_view_private.h" in Tools + https://bugs.webkit.org/show_bug.cgi?id=102644 + + Reviewed by Gyuyoung Kim. + + Include ewk_view.h instead of ewk_view_private.h in Tools + + * DumpRenderTree/efl/PixelDumpSupportEfl.cpp: + +2012-11-18 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed, rolling out r135104. + http://trac.webkit.org/changeset/135104 + https://bugs.webkit.org/show_bug.cgi?id=102638 + + Should not use commit queue to add people to committer list. + (Requested by ap_ on #webkit). + + * Scripts/webkitpy/common/config/committers.py: + +2012-11-18 Vivek Galatage <vivek.vg@samsung.com> + + Add myself to committers.py + https://bugs.webkit.org/show_bug.cgi?id=102636 + + Reviewed by Laszlo Gombos. + + Add myself to committers.py + + * Scripts/webkitpy/common/config/committers.py: + +2012-11-18 Genevieve Mak <gmak@rim.com> + + [BlackBerry] Enable Touch Sliders + https://bugs.webkit.org/show_bug.cgi?id=102516 + + Reviewed by Rob Buis. + + Enabled for BlackBerry only + PR #242781 + PR #176014 + + * Scripts/webkitperl/FeatureList.pm: + +2012-11-17 Dimitri Glazkov <dglazkov@chromium.org> + + Remove unused code I wrote a long time ago from gardeningserver.py + https://bugs.webkit.org/show_bug.cgi?id=102605 + + Reviewed by Adam Barth. + + * Scripts/webkitpy/tool/servers/gardeningserver.py: Removed. + * Scripts/webkitpy/tool/servers/gardeningserver_unittest.py: Removed. + +2012-11-16 Tony Chang <tony@chromium.org> + + Remove ENABLE_CSS_HIERARCHIES since it's no longer in use + https://bugs.webkit.org/show_bug.cgi?id=102554 + + Reviewed by Andreas Kling. + + As mentioned in https://bugs.webkit.org/show_bug.cgi?id=79939#c41 , + we're going to revist this feature once additional vendor support is + achieved. + + * Scripts/webkitperl/FeatureList.pm: + +2012-11-16 Jochen Eisinger <jochen@chromium.org> + + [chromium] move stubs from DRTTestRunner to TestRunner + https://bugs.webkit.org/show_bug.cgi?id=102489 + + Reviewed by Adam Barth. + + This is part of moving all methods from DRTTestRunner to TestRunner. + Instead of keeping one stub per method, I'm using a shared stub to + clean up the code. + + * DumpRenderTree/chromium/DRTTestRunner.cpp: + (DRTTestRunner::DRTTestRunner): + * DumpRenderTree/chromium/DRTTestRunner.h: + (DRTTestRunner): + * DumpRenderTree/chromium/TestRunner/src/TestRunner.cpp: + (WebTestRunner::TestRunner::TestRunner): + (WebTestRunner): + (WebTestRunner::TestRunner::fallbackMethod): + (WebTestRunner::TestRunner::notImplemented): + * DumpRenderTree/chromium/TestRunner/src/TestRunner.h: + (WebTestRunner): + (TestRunner): + (WebTestRunner::TestRunner::setDelegate): + * DumpRenderTree/chromium/TestShell.cpp: + (TestShell::createMainWindow): + (TestShell::~TestShell): + +2012-11-16 Jochen Eisinger <jochen@chromium.org> + + [chromium] fake drag drop operations in the WebTestProxyBase instead of the WebViewHost + https://bugs.webkit.org/show_bug.cgi?id=102495 + + Reviewed by Adam Barth. + + When a drag operation is initiated in a layout test, we need to + simulate a corresponding drop event, otherwise the WebViewImpl will sit + there waiting for it. Instead of having the embedder taking care of + this, move this into the TestRunner library. + + * DumpRenderTree/chromium/TestRunner/public/WebTestProxy.h: + (WebKit): + (WebTestProxyBase): + (WebTestRunner::WebTestProxy::startDragging): + * DumpRenderTree/chromium/TestRunner/src/WebTestProxy.cpp: + (WebTestRunner::WebTestProxyBase::startDragging): + (WebTestRunner): + * DumpRenderTree/chromium/WebViewHost.cpp: + * DumpRenderTree/chromium/WebViewHost.h: + (WebViewHost): + +2012-11-16 Tien-Ren Chen <trchen@chromium.org> + + Rename applyDefaultDeviceScaleFactorInCompositor to setApplyDeviceScaleFactorInCompositor + https://bugs.webkit.org/show_bug.cgi?id=102462 + + Reviewed by James Robinson. + + As we no longer have this "default" device scale factor. + + * DumpRenderTree/chromium/WebPreferences.cpp: + (WebPreferences::applyTo): + +2012-11-15 Takashi Sakamoto <tasak@google.com> + + [Win] key event's location does not work on Windows platform. + https://bugs.webkit.org/show_bug.cgi?id=89742 + + Reviewed by Brent Fulgham. + + Modified keyDownCallback to use lparam to specify left-hand keys or + right-hand keys. + + * DumpRenderTree/win/EventSender.cpp: + (makeKeyDataForScanCode): + Given a virtual keycode, generate scancode and extended key bit of + lparam. + (keyDownCallback): + Use lparam for left-hand and right-hand keys, because Windows doesn't + directly provide a virtual keycode which distinguishes between + left-hand and right-hand. For example, when control key is pressed, + wparam has VK_CONTROL, neither VK_RCONTROL nor VK_LCONTROL. + +2012-11-16 Tommy Widenflycht <tommyw@google.com> + + [chromium] MediaStream API: Add missing WebRTCPeerConnectionHandlerClient::didAddRemoteDataChannel + https://bugs.webkit.org/show_bug.cgi?id=102386 + + Reviewed by Adam Barth. + + Adding mock data channel functionality. + + * DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp: + (MockWebRTCPeerConnectionHandler::openDataChannel): + +2012-11-16 Jochen Eisinger <jochen@chromium.org> + + [chromium] delete unused testRunner methods + https://bugs.webkit.org/show_bug.cgi?id=102479 + + Reviewed by Adam Barth. + + These methods aren't used by any layout test. Remove them to avoid bit rot + + * DumpRenderTree/chromium/DRTTestRunner.cpp: + (DRTTestRunner::DRTTestRunner): + (DRTTestRunner::reset): + * DumpRenderTree/chromium/DRTTestRunner.h: + (DRTTestRunner): + * DumpRenderTree/chromium/WebViewHost.cpp: + (WebViewHost::shouldBeginEditing): + (WebViewHost::shouldEndEditing): + (WebViewHost::shouldInsertNode): + (WebViewHost::shouldInsertText): + (WebViewHost::shouldChangeSelectedRange): + (WebViewHost::shouldDeleteRange): + (WebViewHost::shouldApplyStyle): + (WebViewHost::startDragging): + (WebViewHost::enterFullScreenNow): + (WebViewHost::exitFullScreenNow): + +2012-11-15 Alexey Proskuryakov <ap@apple.com> + + Private Browsing is a per-page setting that sets a global value + https://bugs.webkit.org/show_bug.cgi?id=67870 + + Reviewed by Sam Weinig. + + * DumpRenderTree/mac/DumpRenderTree.mm: (setDefaultsToConsistentValuesForTesting): + Call _switchNetworkLoaderToNewTestingSession before making other settings, so that + they would actually apply to the testing session. + + * WebKitTestRunner/InjectedBundle/InjectedBundle.cpp: + (WTR::InjectedBundle::initialize): + (WTR::InjectedBundle::beginTesting): + Only call WKBundleSwitchNetworkLoaderToNewTestingSession once per process, matching + WebKit1. I'm not fully sure what is going wrong, but apparently creating mutiple + sessions with the same identifier doesn't quite work. + +2012-11-16 Yael Aharon <yael.aharon@intel.com> + + Unreviewed. Help bugzilla find me. + + * Scripts/webkitpy/common/config/committers.py: + +2012-11-16 Peter Beverloo <peter@chromium.org> + + Running TestWebKitAPI and webkit_unit_tests for Chromium Android should defer to the Chromium-sided test runner + https://bugs.webkit.org/show_bug.cgi?id=102245 + + Reviewed by Tony Chang. + + When running TestWebKitAPI and webkit_unit_test for Chromium Android, defer + the actual running part to the test runner which lives on the Chromium side. + Re-implementing or even generalizing the device-interaction part in WebKit + is error prone and not worth the effort. + + * Scripts/run-api-tests: + * Scripts/run-chromium-webkit-unit-tests: + +2012-11-15 Yury Semikhatsky <yurys@chromium.org> + + Memory instrumentation: add code for reporting stack traces of unknown instrumented objects + https://bugs.webkit.org/show_bug.cgi?id=102384 + + Reviewed by Pavel Feldman. + + Updated return type in accord with the changes in MemoryInstrumentationClient. + + * TestWebKitAPI/Tests/WTF/MemoryInstrumentationTest.cpp: + +2012-11-15 Gustavo Noronha Silva <gns@gnome.org> + + [GTK] Split WebCore/platform into a separate library + https://bugs.webkit.org/show_bug.cgi?id=94435 + + Reviewed by Martin Robinson. + + More people have been reporting problems when linking WebCore because + the command line limit is being exceeded. Splitting WebCore a bit more + is in order. + + * GNUmakefile.am: link libWebCorePlatform into DRT + +2012-11-15 Dana Jansens <danakj@chromium.org> + + [chromium] Stop using the WebCompositorSupport methods for changing settings + https://bugs.webkit.org/show_bug.cgi?id=101968 + + Reviewed by James Robinson. + + * DumpRenderTree/chromium/TestShell.cpp: + * DumpRenderTree/chromium/TestShell.h: + (TestShell::setPerTilePaintingEnabled): + (TestShell::setAcceleratedAnimationEnabled): + +2012-11-15 Tony Chang <tony@chromium.org> + + Generate Settings from a .in file + https://bugs.webkit.org/show_bug.cgi?id=100393 + + Reviewed by Adam Barth. + + Add the generated WebCore files to the include dir. + + * TestWebKitAPI/CMakeLists.txt: + * WebKitTestRunner/CMakeLists.txt: + +2012-11-15 Roger Fong <roger_fong@apple.com> + + Make old-run-webkit-tests handle setting the results directory properly. + https://bugs.webkit.org/show_bug.cgi?id=102273 + <rdar://problem/11571607> + + Reviewed by Timothy Horton. + + A call to chdirWebkit in old-run-webkit-tests set the current working directory to the OpenSource folder. + Thus setting --results-directory to OpenSource/layout-test-results would create OpenSource/layout-test-results inside the main OpenSource folder. + This caused many other problems including failure to upload test results and failed future test runs. + The solution is to save the current working directory before calling chdirWebKit and then reconstructing the full path to the results directory + using the saved directory when setting $testResultsDirectory. + + * Scripts/old-run-webkit-tests: + +2012-11-15 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed, rolling out r134800 and r134805. + http://trac.webkit.org/changeset/134800 + http://trac.webkit.org/changeset/134805 + https://bugs.webkit.org/show_bug.cgi?id=102417 + + This patch broke chromium port (Requested by jianli on + #webkit). + + * DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp: + (MockWebRTCPeerConnectionHandler::openDataChannel): + +2012-11-15 Tommy Widenflycht <tommyw@google.com> + + [chromium] MediaStream API: Add missing WebRTCPeerConnectionHandlerClient::didAddRemoteDataChannel + https://bugs.webkit.org/show_bug.cgi?id=102386 + + Reviewed by Adam Barth. + + Adding mock data channel functionality. + + * DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp: + (MockWebRTCPeerConnectionHandler::openDataChannel): + +2012-11-15 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed, rolling out r134649 and r134665. + http://trac.webkit.org/changeset/134649 + http://trac.webkit.org/changeset/134665 + https://bugs.webkit.org/show_bug.cgi?id=102413 + + Broke a ton of downstream chromium tests (Requested by japhet + on #webkit). + + * DumpRenderTree/chromium/WebViewHost.cpp: + (WebViewHost::updateForCommittedLoad): + +2012-11-15 Andreas Kling <akling@apple.com> + + Update my e-mail address. + + Rubber-stamped by Anders Koivisto. + + * Scripts/webkitpy/common/config/committers.py: + +2012-11-15 Dominik Röttsches <dominik.rottsches@intel.com> + + [EFL] Bump Harfbuzz to allow fixing bug 101009 on EFL + https://bugs.webkit.org/show_bug.cgi?id=101323 + + Reviewed by Martin Robinson. + + Bumping Harfbuzz to newer version so that we can remove the + ifdef round the fix for bug 101009 for EFL, too. + We're using the zip snapshot since jhbuild can fallback to the previously + downloaded blob in case of network failures which leads to better + buildbot robustness. This zip snapshot currently needs to be locally + patched to fix ICU detection on systems that don't have icu pkg-config files. + The patch is suggested for merging into HarfBuzz. We can remove it locally + once it's accepted into HarfBuzz upstream. + + * efl/patches/harfbuzz-icu-detection-fix.patch: Applied after retrieving source to fix harfbuzz detection on systems that don't have pkg-config files for it. + * efl/jhbuild.modules: Bumping harfbuzz version. + +2012-11-15 Alexey Proskuryakov <ap@apple.com> + + [Mac] Implement WTR --no-timeout-at-all option + https://bugs.webkit.org/show_bug.cgi?id=102251 + + Reviewed by Eric Carlson. + + * WebKitTestRunner/mac/TestControllerMac.mm: (WTR::TestController::platformRunUntil): + Just do it, and convert to Objective C on the way for simplicity. + +2012-11-14 Ryuan Choi <ryuan.choi@gmail.com> + + [EFL] Port tiled backing store + https://bugs.webkit.org/show_bug.cgi?id=71352 + + Reviewed by Gyuyoung Kim. + + * EWebLauncher/main.c: Added option to test the WebCore's tiled backing store. + (_User_Arguments): + (windowCreate): + (parseUserArguments): + +2012-11-14 Andy Estes <aestes@apple.com> + + Fix the build. + + * TestWebKitAPI/mac/TestBrowsingContextLoadDelegate.h: + +2012-11-14 Dirk Pranke <dpranke@chromium.org> + + webkitpy: consolidate webkit-base-finding code + https://bugs.webkit.org/show_bug.cgi?id=102007 + + Reviewed by Eric Seidel. + + This patch creates a new "WebKitFinder" class that other + modules can use to find the top of the WebKit tree and + commonly used subdirectories. This logic was in the + webkitpy.layout_test.port classes but wasn't specific to those + classes and now can be used by other modules without needing a port + (e.g., by the check-webkit-style python linter). + + This code is somewhat redundant with the code for find_checkout_root() + in the scm modules, but it does not rely on the presence of a version + control system to work. This is a requirement for some uses of the + tree (e.g., Chromium tester checkouts). + + This patch removes most of the logic from the layout_tests.port.config + module and makes that as private as possible. Now we just need to move + the default_configuration and flag_from_configuration logic into + DeprecatedPort (or someplace else appropriate) and we can finish + getting rid of the Config class (but that is a separate patch). + + * Scripts/webkitpy/common/webkit_finder.py: Added. + (WebKitFinder): + (WebKitFinder.__init__): + (WebKitFinder.webkit_base): + (WebKitFinder.path_from_webkit_base): + (WebKitFinder.path_to_script): + (WebKitFinder.layout_tests_dir): + (WebKitFinder.perf_tests_dir): + * Scripts/webkitpy/layout_tests/port/base.py: + (Port.__init__): + (Port): + (Port.webkit_base): + (Port.path_from_webkit_base): + (Port.path_to_script): + (Port.layout_tests_dir): + (Port.perf_tests_dir): + (Port.set_option_default): + (Port._run_script): + * Scripts/webkitpy/layout_tests/port/base_unittest.py: + (PortTest.test_diff_text): + * Scripts/webkitpy/layout_tests/port/chromium_linux.py: + (ChromiumLinuxPort._determine_driver_path_statically): + * Scripts/webkitpy/layout_tests/port/chromium_unittest.py: + * Scripts/webkitpy/layout_tests/port/config.py: + (Config.__init__): + (Config.build_directory): + (Config.default_configuration): + (Config._read_configuration): + * Scripts/webkitpy/layout_tests/port/config_mock.py: Removed. + * Scripts/webkitpy/layout_tests/port/config_unittest.py: + (ConfigTest.test_default_configuration__standalone): + (ConfigTest.test_default_configuration__scripterror): + * Scripts/webkitpy/layout_tests/port/driver_unittest.py: + (DriverTest.make_port): + (DriverTest.test_no_timeout): + * Scripts/webkitpy/layout_tests/port/gtk.py: + (GtkPort.setup_environ_for_server): + * Scripts/webkitpy/layout_tests/port/mac.py: + (MacPort.show_results_html_file): + * Scripts/webkitpy/layout_tests/port/port_testcase.py: + (TestWebKitPort.__init__): + (PortTestCase.make_port): + * Scripts/webkitpy/layout_tests/port/win_unittest.py: + (WinPortTest.test_expectations_files): + * Scripts/webkitpy/layout_tests/port/xvfbdriver_unittest.py: + (XvfbDriverTest.make_driver): + (XvfbDriverTest.test_stop): + * Scripts/webkitpy/style/checkers/python.py: + (Pylinter.__init__): + +2012-11-14 Dana Jansens <danakj@chromium.org> + + [chromium] WebPreferences reset() should set perTilePainting and acceleratedAnimation settings to false. + https://bugs.webkit.org/show_bug.cgi?id=102296 + + Reviewed by James Robinson. + + These settings are always set by TestShell anyhow, but we should be + setting them to false here along with everything else. + + * DumpRenderTree/chromium/WebPreferences.cpp: + (WebPreferences::reset): + +2012-11-08 Andy Estes <aestes@apple.com> + + [WebKit2] Need API in UIProcess to enable loading of custom protocols + https://bugs.webkit.org/show_bug.cgi?id=101674 + + Reviewed by Brady Eidson. + + Add an API test that implements a custom protocol and attempts to load + a resource requiring that protocol in a WKView. The test passes only if + didFinishLoadForFrame: fires. + + * TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj: + * TestWebKitAPI/Tests/WebKit2ObjC/CustomProtocolsTest.mm: Added. + (+[TestProtocol canInitWithRequest:]): + (+[TestProtocol canonicalRequestForRequest:]): + (+[TestProtocol requestIsCacheEquivalent:toRequest:]): + (-[TestProtocol startLoading]): + (-[TestProtocol stopLoading]): + * TestWebKitAPI/Tests/WebKit2ObjC/UserContentTest.mm: + * TestWebKitAPI/mac/TestBrowsingContextLoadDelegate.h: Copied from Source/WebKit2/UIProcess/API/mac/WKBrowsingContextControllerInternal.h. + * TestWebKitAPI/mac/TestBrowsingContextLoadDelegate.mm: Copied from Source/WebKit2/UIProcess/API/mac/WKBrowsingContextControllerInternal.h. + (-[TestBrowsingContextLoadDelegate initWithBlockToRunOnLoad:]): + (-[TestBrowsingContextLoadDelegate browsingContextControllerDidFinishLoad:]): + +2012-11-14 Ojan Vafai <ojan@chromium.org> + + Fix some defuct flakiness dashboard unittests. + * TestResultServer/static-dashboards/flakiness_dashboard_unittests.js: + +2012-11-14 Glenn Adams <glenn@skynav.com> + + webkitpy: print-expectations - add --paths option to print only paths of test expectation files + https://bugs.webkit.org/show_bug.cgi?id=102269 + + Reviewed by Dirk Pranke. + + Add --paths option to print-expectations command in order to obtain list of applicable + test expectation file paths. + + * Scripts/webkitpy/tool/commands/queries.py: + (PrintExpectations.__init__): + (PrintExpectations.execute): + * Scripts/webkitpy/tool/commands/queries_unittest.py: + (PrintExpectationsTest.run_test): + (PrintExpectationsTest.test_paths): + +2012-11-14 James Robinson <jamesr@chromium.org> + + webgl-background-color.html started failing + https://bugs.webkit.org/show_bug.cgi?id=102247 + + Reviewed by Adrienne Walker. + + The compositor thread should outlive the WebView. + + * DumpRenderTree/chromium/TestShell.h: + (TestShell): + +2012-11-14 Nate Chapin <japhet@chromium.org> + + Move empty loading to DocumentLoader, simplify FrameLoader::init() + https://bugs.webkit.org/show_bug.cgi?id=101512 + + Reviewed by Adam Barth. + + Chromium DRT has some code that doesn't play nicely with empty urls and incorrectly + interprets them as a non-empty load. This ensures + http/tests/navigation/new-window-redirect-history.html continues to pass + in chromium. + + * DumpRenderTree/chromium/WebViewHost.cpp: + (WebViewHost::updateForCommittedLoad): + +2012-11-14 Zan Dobersek <zandobersek@gmail.com> + + Remove uses of deprecated unittest.TestCase aliases + https://bugs.webkit.org/show_bug.cgi?id=102253 + + Reviewed by Dirk Pranke. + + Replace the deprecated unittest.TestCase methods with the corresponding methods + everywhere inside the Tools directory. The following replacements are done: + - assertEquals -> assertEqual + - assert_ -> assertTrue + - failUnlessRaises -> assertRaises + + * BuildSlaveSupport/build.webkit.org-config/mastercfg_unittest.py: + (SVNMirrorTest.test_CheckOutSource): + * QueueStatusServer/model/queuepropertymixin_unittest.py: + (QueuePropertyMixinTest.test_queue_property): + * QueueStatusServer/model/queues_unittest.py: + (QueueTest._assert_short_name): + (QueueTest._assert_display_name): + (QueueTest._assert_name_with_underscores): + * QueueStatusServer/model/workitems_unittest.py: + (WorkItemsTest.test_display_position_for_attachment): + * Scripts/webkitpy/common/checkout/changelog_unittest.py: + (test_parse_log_entries_from_changelog): + (test_parse_log_entries_from_annotated_file): + (_assert_parse_reviewer_text_and_list): + (_assert_parse_reviewer_text_list): + (_assert_fuzzy_reviewer_match): + (_assert_parse_authors): + (test_latest_entry_parse): + (test_latest_entry_parse_single_entry): + (test_set_reviewer): + (test_set_short_description_and_bug_url): + * Scripts/webkitpy/common/checkout/diff_parser_unittest.py: + (DiffParserTest.test_diff_parser): + * Scripts/webkitpy/common/checkout/scm/scm_unittest.py: + (GitSVNTest.test_revisions_changing_files_with_local_commit): + (GitSVNTest.test_upstream_branch): + (GitSVNTest.test_create_patch_with_rm_and_changed_files): + (GitTestWithMock.test_push_local_commits_to_server_with_username_and_password): + * Scripts/webkitpy/common/config/ports_unittest.py: + (DeprecatedPortTest.test_mac_port): + (DeprecatedPortTest.test_gtk_port): + (DeprecatedPortTest.test_efl_port): + (DeprecatedPortTest.test_qt_port): + (DeprecatedPortTest.test_chromium_port): + (DeprecatedPortTest.test_chromium_android_port): + (DeprecatedPortTest.test_chromium_xvfb_port): + * Scripts/webkitpy/common/config/urls_unittest.py: + (URLsTest.test_parse_bug_id): + (URLsTest.test_parse_attachment_id): + * Scripts/webkitpy/common/find_files_unittest.py: + (TestWinNormalize.assert_filesystem_normalizes): + * Scripts/webkitpy/common/net/bugzilla/bugzilla_unittest.py: + (test_url_creation): + (test_parse_bug_id): + (_assert_dictionaries_equal): + (test_parse_bugs_from_xml): + (test_attachment_detail_bug_parsing): + (_assert_result_count): + (test_request_page_parsing): + (test_quip_page_parsing): + (EditUsersParserTest._assert_login_userid_pairs): + * Scripts/webkitpy/common/net/buildbot/buildbot_unittest.py: + (test_status_parsing): + (test_latest_cached_build): + (test_results_zip_url): + * Scripts/webkitpy/common/net/credentials_unittest.py: + (test_credentials_from_environment): + * Scripts/webkitpy/common/net/failuremap_unittest.py: + (FailureMapTest.test_failing_revisions): + (FailureMapTest.test_new_failures): + (FailureMapTest.test_new_failures_with_old_revisions): + (FailureMapTest.test_new_failures_with_more_old_revisions): + (FailureMapTest.test_tests_failing_for): + (FailureMapTest.test_failing_tests): + * Scripts/webkitpy/common/net/layouttestresults_unittest.py: + (LayoutTestResultsTest.test_set_failure_limit_count): + * Scripts/webkitpy/common/net/unittestresults_unittest.py: + (UnitTestResultsTest.test_nostring): + (UnitTestResultsTest.test_emptystring): + * Scripts/webkitpy/common/read_checksum_from_png_unittest.py: + (ReadChecksumFromPngTest.test_read_checksum): + * Scripts/webkitpy/common/system/deprecated_logging_unittest.py: + (LoggingTest.assert_log_equals): + * Scripts/webkitpy/common/system/executive_unittest.py: + (ScriptErrorTest.test_string_from_args): + (ScriptErrorTest.test_message_with_output): + (ExecutiveTest.test_run_command_with_bad_command): + (ExecutiveTest.test_run_command_with_unicode): + (ExecutiveTest.serial_test_run_in_parallel): + * Scripts/webkitpy/common/system/filesystem_mock_unittest.py: + (MockFileSystemTest.quick_check): + * Scripts/webkitpy/common/system/filesystem_unittest.py: + (GenericFileSystemTests.test_glob__trailing_asterisk): + (GenericFileSystemTests.test_glob__leading_asterisk): + (GenericFileSystemTests.test_glob__middle_asterisk): + (GenericFileSystemTests.test_glob__period_is_escaped): + (RealFileSystemTest.test_chdir): + (RealFileSystemTest.test_remove_file_with_retry): + (RealFileSystemTest.test_sep): + * Scripts/webkitpy/common/system/logtesting.py: + (TestLogStream.assertMessages): + * Scripts/webkitpy/common/system/logutils_unittest.py: + (GetLoggerTest.test_get_logger_in_webkitpy): + (GetLoggerTest.test_get_logger_not_in_webkitpy): + * Scripts/webkitpy/common/system/outputcapture.py: + (OutputCaptureTestCaseBase.assertStdout): + (OutputCaptureTestCaseBase.assertStderr): + * Scripts/webkitpy/common/system/path_unittest.py: + (AbspathTest.test_abspath_to_uri_cygwin): + (AbspathTest.test_abspath_to_uri_unixy): + (AbspathTest.test_abspath_to_uri_win): + (AbspathTest.test_abspath_to_uri_escaping_unixy): + (AbspathTest.test_abspath_to_uri_escaping_cygwin): + * Scripts/webkitpy/common/system/platforminfo_unittest.py: + (TestPlatformInfo.test_real_code): + (TestPlatformInfo.test_os_name_and_wrappers): + (TestPlatformInfo.test_os_version): + (TestPlatformInfo.test_total_bytes_memory): + * Scripts/webkitpy/common/system/user_unittest.py: + (UserTest.test_confirm.mock_raw_input): + (UserTest.test_confirm): + * Scripts/webkitpy/common/system/zipfileset_unittest.py: + (ZipFileSetTest.test_open): + (ZipFileSetTest.test_read): + * Scripts/webkitpy/common/watchlist/watchlist_unittest.py: + (WatchListTest.test_filename_definition_no_matches): + (WatchListTest.test_filename_definition): + (WatchListTest.test_cc_rules_simple): + (WatchListTest.test_cc_rules_complex): + (WatchListTest.test_cc_and_message_rules_complex): + (WatchListTest.test_cc_and_message_rules_no_matches): + (WatchListTest.test_added_match): + (WatchListTest.test_deleted_match): + (WatchListTest.test_more_and_less_match): + (WatchListTest.test_complex_match): + * Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py: + (LockCheckingRunner.handle_finished_list): + (LayoutTestRunnerTests.test_interrupt_if_at_failure_limits): + (LayoutTestRunnerTests.test_update_summary_with_result): + (LayoutTestRunnerTests.test_servers_started): + (SharderTests.assert_shards): + (SharderTests.test_shard_in_two_has_no_locked_shards): + (SharderTests.test_shard_in_two_has_no_unlocked_shards): + (NaturalCompareTest.assert_cmp): + (KeyCompareTest.assert_cmp): + * Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py: + (TestConfigurationTest.test_items): + (TestConfigurationTest.test_keys): + (TestConfigurationTest.test_str): + (TestConfigurationTest.test_repr): + (TestConfigurationTest.test_hash): + (TestConfigurationTest.test_eq): + (TestConfigurationTest.test_values): + (SpecifierSorterTest.test_init): + (SpecifierSorterTest.test_add_specifier): + (SpecifierSorterTest.test_add_macros): + (SpecifierSorterTest.test_category_priority): + (SpecifierSorterTest.test_specifier_priority): + (SpecifierSorterTest.test_sort_specifiers): + (TestConfigurationConverterTest.test_symmetric_difference): + (TestConfigurationConverterTest.test_to_config_set): + (TestConfigurationConverterTest.test_macro_expansion): + (TestConfigurationConverterTest.test_to_specifier_lists): + (TestConfigurationConverterTest.test_macro_collapsing): + (TestConfigurationConverterTest.test_converter_macro_collapsing): + (TestConfigurationConverterTest.test_specifier_converter_access): + * Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py: + (assert_exp): + (MiscTests.test_result_was_expected): + (MiscTests.test_remove_pixel_failures): + (MiscTests.test_suffixes_for_expectations): + (MiscTests.test_get_expectations_string): + (SkippedTests.check): + (ExpectationSyntaxTests.assert_tokenize_exp): + (SemanticTests.test_bad_bugid): + (SemanticTests.test_missing_bugid): + (TestExpectationSerializationTests.test_reconstitute_only_these): + * Scripts/webkitpy/layout_tests/models/test_failures_unittest.py: + (TestFailuresTest.test_crashes): + * Scripts/webkitpy/layout_tests/port/base_unittest.py: + (PortTest.test_nonexistant_expectations): + (PortTest.test_additional_expectations): + * Scripts/webkitpy/layout_tests/port/builders_unittest.py: + (BuildersTest.test_path_from_name): + * Scripts/webkitpy/layout_tests/port/chromium_android_unittest.py: + (ChromiumAndroidPortTest.test_attributes): + (ChromiumAndroidPortTest.test_default_timeout_ms): + (ChromiumAndroidPortTest.test_get_devices_one_device): + (ChromiumAndroidPortTest.test_get_devices_two_devices): + (ChromiumAndroidPortTest.test_get_device_serial_one_device): + (ChromiumAndroidPortTest.test_get_device_serial_two_devices): + (ChromiumAndroidPortTest.test_must_require_http_server): + (ChromiumAndroidDriverTest.test_get_last_stacktrace): + (ChromiumAndroidDriverTest.test_get_crash_log): + (ChromiumAndroidDriverTest.test_cmd_line): + (ChromiumAndroidDriverTest.test_read_prompt): + (ChromiumAndroidDriverTest.test_command_from_driver_input): + (ChromiumAndroidDriverTwoDriversTest.test_two_drivers): + (ChromiumAndroidTwoPortsTest.test_options_with_two_ports): + * Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py: + (ChromiumLinuxPortTest.assert_architecture): + (ChromiumLinuxPortTest.test_determine_architecture_fails): + (ChromiumLinuxPortTest.test_path_to_image_diff): + * Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py: + (ChromiumMacPortTest.assert_name): + (ChromiumMacPortTest.test_baseline_path): + (ChromiumMacPortTest.test_path_to_image_diff): + * Scripts/webkitpy/layout_tests/port/chromium_port_testcase.py: + (ChromiumPortTestCase.test_default_max_locked_shards): + (ChromiumPortTestCase.test_default_timeout_ms): + (ChromiumPortTestCase.test_default_pixel_tests): + (ChromiumPortTestCase.test_all_test_configurations): + (ChromiumPortTestCase.test_default_configuration): + (ChromiumPortTestCase.test_diff_image): + (ChromiumPortTestCase.test_diff_image_crashed): + (ChromiumPortTestCase.test_expectations_files): + * Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py: + (ChromiumWinTest.test_setup_environ_for_server_cygpath): + (ChromiumWinTest.assert_name): + (ChromiumWinTest.test_baseline_path): + (ChromiumWinTest.test_path_to_image_diff): + * Scripts/webkitpy/layout_tests/port/driver_unittest.py: + (DriverTest.test_read_block): + (DriverTest.test_read_binary_block): + (DriverTest.test_read_base64_block): + (DriverTest.test_no_timeout): + (DriverTest.test_check_for_driver_crash.assert_crash): + (DriverTest.test_creating_a_port_does_not_write_to_the_filesystem): + * Scripts/webkitpy/layout_tests/port/factory_unittest.py: + (FactoryTest.test_get_from_builder_name): + * Scripts/webkitpy/layout_tests/port/gtk_unittest.py: + (GtkPortTest.test_default_timeout_ms): + * Scripts/webkitpy/layout_tests/port/http_lock_unittest.py: + (HttpLockTest.test_current_lock_pid): + * Scripts/webkitpy/layout_tests/port/image_diff_unittest.py: + (TestImageDiffer.test_diff_image_failed): + (TestImageDiffer.test_diff_image_passed): + * Scripts/webkitpy/layout_tests/port/leakdetector_unittest.py: + (LeakDetectorTest.test_leaks_args): + (test_parse_leaks_output): + (test_leaks_files_in_directory): + (test_count_total_leaks): + * Scripts/webkitpy/layout_tests/port/mac_unittest.py: + (MacTest.test_default_timeout_ms): + (assert_name): + (test_setup_environ_for_server): + (_assert_search_path): + (test_32bit): + (test_64bit): + * Scripts/webkitpy/layout_tests/port/mock_drt_unittest.py: + (MockTestShellTest.test_pixeltest__fails): + (MockTestShellTest.test_test_shell_parse_options): + * Scripts/webkitpy/layout_tests/port/port_testcase.py: + (PortTestCase.test_default_max_locked_shards): + (PortTestCase.test_default_timeout_ms): + (PortTestCase.test_default_pixel_tests): + (PortTestCase.test_diff_image): + (PortTestCase.test_diff_image_crashed): + (PortTestCase.test_get_crash_log): + (PortTestCase.assert_build_path): + (PortTestCase.test_expectations_ordering): + (_assert_config_file_for_platform): + (test_path_to_apache_config_file): + (test_additional_platform_directory): + * Scripts/webkitpy/layout_tests/port/qt_unittest.py: + (QtPortTest._assert_search_path): + (QtPortTest._assert_expectations_files): + (QtPortTest.test_setup_environ_for_server): + * Scripts/webkitpy/layout_tests/port/server_process_unittest.py: + (TestServerProcess.test_basic): + (TestServerProcess.test_broken_pipe): + * Scripts/webkitpy/layout_tests/port/win_unittest.py: + (WinPortTest._assert_search_path): + (WinPortTest._assert_version): + (WinPortTest.test_runtime_feature_list): + (WinPortTest.test_expectations_files): + * Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py: + (LintTest.test_all_configurations): + (MainTest.test_all): + (MainTest.test_repeat_each): + (MainTest.test_skipped_flag): + (MainTest.test_iterations): + (MainTest.test_run_chunk): + (MainTest.test_run_part): + (MainTest.test_run_singly): + (MainTest.test_run_singly_actually_runs_tests): + (MainTest.test_single_file): + (MainTest.test_single_file_with_prefix): + (MainTest.test_single_skipped_file): + (MainTest.test_stderr_is_saved): + (MainTest.test_test_list): + (MainTest.test_test_list_with_prefix): + (MainTest.test_missing_and_unexpected_results): + (MainTest.test_pixel_test_directories): + (MainTest.test_missing_and_unexpected_results_with_custom_exit_code): + (MainTest.test_crash_log): + (MainTest.test_web_process_crash_log): + (MainTest.test_exit_after_n_failures_upload): + (MainTest.test_exit_after_n_failures): + (MainTest.test_exit_after_n_crashes): + (MainTest.test_retrying_and_flaky_tests): + (MainTest.test_run_order__inline): + (MainTest.test_reftest_run): + (MainTest.test_reftest_run_reftests_if_pixel_tests_are_disabled): + (MainTest.test_reftest_skip_reftests_if_no_ref_tests): + (MainTest.test_reftest_expected_html_should_be_ignored): + (MainTest.test_reftest_driver_should_run_expected_html): + (MainTest.test_reftest_driver_should_run_expected_mismatch_html): + (MainTest.test_output_diffs): + (MainTest.test_unsupported_platform): + (EndToEndTest.test_end_to_end): + (RebaselineTest.test_reset_results): + (RebaselineTest.test_missing_results): + (RebaselineTest.test_new_baseline): + * Scripts/webkitpy/layout_tests/servers/http_server_integrationtest.py: + (BaseTest.integration_test_server__normal): + (BaseTest.integration_test_server__fails): + (BaseTest.integration_test_port_and_root): + * Scripts/webkitpy/layout_tests/servers/http_server_unittest.py: + (TestHttpServer.test_start_cmd): + * Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py: + (RegularTest.test_logging_not_included): + (RegularTest._basic): + (RegularTest.test_basic): + (RegularTest.test_log_after_update): + (RegularTest.test_log_args): + (TtyTest.test_basic): + (TtyTest.test_log_after_update): + (VerboseTest.test_basic): + (VerboseTest.test_log_after_update): + (VerboseTest.test_log_args): + * Scripts/webkitpy/layout_tests/views/printing_unittest.py: + (Testprinter.assertWritten): + (test_test_status_line): + * Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py: + (MainTest.assertWritten): + * Scripts/webkitpy/style/checker_unittest.py: + (GlobalVariablesTest.test_webkit_base_filter_rules): + (CheckerDispatcherSkipTest._assert_should_skip_without_warning): + (CheckerDispatcherCarriageReturnTest.test_should_check_and_strip_carriage_returns): + (CheckerDispatcherDispatchTest.assert_checker): + (CheckerDispatcherDispatchTest.test_changelog_paths): + (CheckerDispatcherDispatchTest.test_cpp_paths): + (CheckerDispatcherDispatchTest.test_json_paths): + (CheckerDispatcherDispatchTest.test_python_paths): + (CheckerDispatcherDispatchTest.test_text_paths): + (CheckerDispatcherDispatchTest.test_xml_paths): + (StyleProcessorConfigurationTest.test_init): + (StyleProcessorConfigurationTest.test_write_style_error_emacs): + (StyleProcessorConfigurationTest.test_write_style_error_vs7): + (StyleProcessor_EndToEndTest.test_init): + (StyleProcessor_EndToEndTest.test_process): + (StyleProcessor_CodeCoverageTest.test_process__checker_dispatched): + * Scripts/webkitpy/style/checkers/changelog_unittest.py: + (ChangeLogCheckerTest.assert_error.handle_style_error): + (ChangeLogCheckerTest.test_init): + * Scripts/webkitpy/style/checkers/common_unittest.py: + (CarriageReturnCheckerTest.assert_carriage_return): + (TabCheckerTest.assert_tab): + * Scripts/webkitpy/style/checkers/cpp_unittest.py: + (CppFunctionsTest.test_convert_to_lower_with_underscores): + (CppFunctionsTest.test_create_acronym): + (CppFunctionsTest.test_parameter): + (CppFunctionsTest.test_single_line_view): + (CppFunctionsTest.test_create_skeleton_parameters): + (CppFunctionsTest.test_find_parameter_name_index): + (CppFunctionsTest.test_parameter_list): + (CppFunctionsTest.test_check_parameter_against_text): + (CppStyleTestBase.perform_lint): + (CppStyleTestBase.assert_lint): + (CppStyleTestBase.assert_lint_one_of_many_errors_re): + (CppStyleTestBase.assert_multi_line_lint): + (CppStyleTestBase.assert_language_rules_check): + (CppStyleTestBase.assert_include_what_you_use): + (CppStyleTestBase.assert_blank_lines_check): + (CppStyleTestBase.assert_positions_equal): + (FunctionDetectionTest.perform_function_detection): + (CppStyleTest.test_get_line_width): + (CppStyleTest.test_find_next_multi_line_comment_start): + (CppStyleTest.test_find_next_multi_line_comment_end): + (CppStyleTest.test_remove_multi_line_comments_from_range): + (CppStyleTest.test_position): + (CppStyleTest.test_rfind_in_lines): + (CppStyleTest.test_close_expression): + (CppStyleTest.test_include_what_you_use_no_implementation_files): + (CppStyleTest.test_include_what_you_use): + (CppStyleTest.test_files_belong_to_same_module): + (CppStyleTest.test_cleanse_line): + (CppStyleTest.test_multiline_strings): + (CppStyleTest.test_newline_at_eof.do_test): + (CppStyleTest.test_invalid_utf8.do_test): + (CppStyleTest.test_is_blank_line): + (CppStyleTest.test_allow_blank_line_before_closing_namespace): + (CppStyleTest.test_allow_blank_line_before_if_else_chain): + (CppStyleTest.test_else_on_same_line_as_closing_braces): + (CppStyleTest.test_build_header_guard): + (CppStyleTest.test_legal_copyright): + (CleansedLinesTest.test_init): + (CleansedLinesTest.test_init_empty): + (CleansedLinesTest.test_collapse_strings): + (CheckForFunctionLengthsTest.assert_function_lengths_check): + (PassPtrTest.assert_pass_ptr_check): + (LeakyPatternTest.assert_leaky_pattern_check): + (WebKitStyleTest.test_parameter_names): + (WebKitStyleTest.test_webkit_export_check): + (CppCheckerTest.test_init): + * Scripts/webkitpy/style/checkers/jsonchecker_unittest.py: + (JSONCheckerTest.assert_error.handle_style_error): + (JSONCheckerTest.test_init): + * Scripts/webkitpy/style/checkers/png_unittest.py: + (PNGCheckerTest.test_init): + (PNGCheckerTest.test_check): + * Scripts/webkitpy/style/checkers/python_unittest.py: + (PythonCheckerTest.test_init): + (PythonCheckerTest.test_check): + * Scripts/webkitpy/style/checkers/test_expectations_unittest.py: + (TestExpectationsTestCase._expect_port_for_expectations_path): + (TestExpectationsTestCase.assert_lines_lint): + * Scripts/webkitpy/style/checkers/text_unittest.py: + (TextStyleTestCase.assertNoError): + (TextStyleTestCase.assertError.error_for_test): + (TextStyleTestCase.assertError): + (TextCheckerTest.test_init): + * Scripts/webkitpy/style/checkers/watchlist_unittest.py: + (WatchListTest.test_basic_error_message.handle_style_error): + (WatchListTest): + * Scripts/webkitpy/style/checkers/xcodeproj_unittest.py: + (XcodeProjectFileCheckerTest.assert_error): + * Scripts/webkitpy/style/checkers/xml_unittest.py: + (XMLCheckerTest.assert_error.handle_style_error): + (XMLCheckerTest.test_init): + * Scripts/webkitpy/style/error_handlers_unittest.py: + (DefaultStyleErrorHandlerTest._check_initialized): + (DefaultStyleErrorHandlerTest.test_non_reportable_error): + (DefaultStyleErrorHandlerTest.test_max_reports_per_category): + (DefaultStyleErrorHandlerTest.test_line_numbers): + * Scripts/webkitpy/style/filereader_unittest.py: + (TextFileReaderTest._assert_file_reader): + (TextFileReaderTest.test_process_file__does_not_exist): + (TextFileReaderTest.test_count_delete_only_file): + * Scripts/webkitpy/style/filter_unittest.py: + (CategoryFilterTest.test_init): + (CategoryFilterTest.test_init_default_arguments): + (CategoryFilterTest.test_str): + (FilterConfigurationTest.test_init): + (FilterConfigurationTest.test_default_arguments): + * Scripts/webkitpy/style/main_unittest.py: + (ChangeDirectoryTest._assert_result): + * Scripts/webkitpy/style/optparser_unittest.py: + (ArgumentPrinterTest.test_to_flag_string): + (ArgumentParserTest.test_parse_default_arguments): + (ArgumentParserTest.test_parse_explicit_arguments): + (ArgumentParserTest.test_parse_files): + (CommandOptionValuesTest.test_init): + * Scripts/webkitpy/style/patchreader_unittest.py: + (PatchReaderTest._assert_checked): + * Scripts/webkitpy/test/finder_unittest.py: + (FinderTest.test_additional_system_paths): + (FinderTest.test_to_module): + (FinderTest.check_names): + * Scripts/webkitpy/test/main_unittest.py: + (TesterTest.test_individual_names_are_not_run_twice): + (TesterTest.test_integration_tests_are_not_found_by_default): + (TesterTest.test_integration_tests_are_found): + (TesterTest.integration_test_coverage_works): + * Scripts/webkitpy/test/runner_unittest.py: + (RunnerTest.test_run): + * Scripts/webkitpy/tool/bot/commitqueuetask_unittest.py: + (_expect_validate): + * Scripts/webkitpy/tool/bot/expectedfailures_unittest.py: + (ExpectedFailuresTest._assert_can_trust): + (ExpectedFailuresTest.test_unexpected_failures_observed): + (ExpectedFailuresTest.test_unexpected_failures_observed_when_tree_is_hosed): + * Scripts/webkitpy/tool/bot/feeders_unittest.py: + (test_patches_with_acceptable_review_flag): + * Scripts/webkitpy/tool/bot/irc_command_unittest.py: + (IRCCommandTest.test_whois): + (IRCCommandTest.test_create_bug): + (IRCCommandTest.test_roll_chromium_deps): + (IRCCommandTest.test_rollout): + * Scripts/webkitpy/tool/bot/layouttestresultsreader_unittest.py: + (LayoutTestResultsReaderTest.test_missing_layout_test_results): + (test_missing_unit_test_results_path): + (test_layout_test_results): + * Scripts/webkitpy/tool/bot/queueengine_unittest.py: + (LoggingDelegate.process_work_item): + (LoggingDelegate.handle_unexpected_error): + (QueueEngineTest.test_trivial): + (QueueEngineTest.test_unexpected_error): + (QueueEngineTest.test_handled_error): + (QueueEngineTest._test_terminating_queue): + * Scripts/webkitpy/tool/commands/openbugs_unittest.py: + (OpenBugsTest.test_find_bugs_in_string): + * Scripts/webkitpy/tool/commands/queries_unittest.py: + (FailureReasonTest.test_blame_line_for_revision): + (PrintExpectationsTest.run_test): + (PrintBaselinesTest.test_basic): + (PrintBaselinesTest.test_multiple): + (PrintBaselinesTest.test_csv): + * Scripts/webkitpy/tool/commands/queues_unittest.py: + (AbstractQueueTest.test_log_directory): + (AbstractPatchQueueTest.test_next_patch): + (test_auto_retry): + * Scripts/webkitpy/tool/commands/rebaseline_unittest.py: + (test_rebaseline_updates_expectations_file): + (test_rebaseline_does_not_include_overrides): + (test_rebaseline_test): + (test_rebaseline_test_with_results_directory): + (test_rebaseline_test_and_print_scm_changes): + (test_rebaseline_and_copy_test): + (test_rebaseline_and_copy_test_no_existing_result): + (test_rebaseline_and_copy_test_with_lion_result): + (test_rebaseline_and_copy_no_overwrite_test): + (test_rebaseline_test_internal_with_move_overwritten_baselines_to): + (TestRebaselineJson.test_rebaseline_all): + (TestRebaselineJson.test_rebaseline_debug): + (TestRebaselineJson.test_move_overwritten): + (TestRebaselineJson.test_no_optimize): + (TestRebaselineJson.test_results_directory): + (TestRebaseline.test_rebaseline): + (TestRebaselineExpectations.test_rebaseline_expectations_noop): + (TestRebaselineExpectations.disabled_test_overrides_are_included_correctly): + (TestAnalyzeBaselines.test_default): + (TestAnalyzeBaselines.test_missing_baselines): + * Scripts/webkitpy/tool/commands/roll_unittest.py: + (PostRollCommandsTest.test_prepare_state): + * Scripts/webkitpy/tool/servers/gardeningserver_unittest.py: + (BuildCoverageExtrapolatorTest.test_extrapolate): + * Scripts/webkitpy/tool/steps/addsvnmimetypeforpng_unittest.py: + (AddSvnMimetypeForPngTest.test_run): + * Scripts/webkitpy/tool/steps/preparechangelog_unittest.py: + (PrepareChangeLogTest.test_ensure_bug_url): + * Scripts/webkitpy/tool/steps/preparechangelogforrevert_unittest.py: + (_assert_message_for_revert_output): + * TestResultServer/model/jsonresults_unittest.py: + (JsonResultsTest._test_merge): + (JsonResultsTest._test_get_test_list): + +2012-11-14 János Badics <jbadics@inf.u-szeged.hu> + + [Qt][ARM] Fix 'nullptr' is a keyword in C++11 [-Wc++0x-compat] warning + https://bugs.webkit.org/show_bug.cgi?id=102083 + + Reviewed by Csaba Osztrogonác. + + Modified compiler name regex in condition that tests if -std=c++0x, c++11, + gnu++0x or gnu++11 are enabled in order to match linux-arm-gnueabi-g++ too, + thus enabling -Wno-c++0x-compat also on ARM compiler. + + * qmake/mkspecs/features/unix/default_post.prf: + +2012-11-14 Thiago Marcos P. Santos <thiago.santos@intel.com> + + REGRESSION(r133757): Causing webkitpy unit tests to fail + https://bugs.webkit.org/show_bug.cgi?id=101444 + + Reviewed by Csaba Osztrogonác. + + Updated the bot name on the unit tests. + + * Scripts/webkitpy/tool/commands/rebaseline_unittest.py: + (TestRebaselineTest.test_baseline_directory): + +2012-11-14 Byungwoo Lee <bw80.lee@samsung.com> + + [EFL][WK2] Rename variables, structures and functions of the MiniBrowser. + https://bugs.webkit.org/show_bug.cgi?id=101517 + + Reviewed by Gyuyoung Kim. + + Rename variables, structures and functions of the MiniBrowser + for the naming consistency. + + 1) Browser_Window* {app_data|browser_window|window} -> window + + 2) Browser_Window::webview -> Browser_Window::ewk_view + The webkit API functions are ewk_view_xxx not webview_xxx. + So using ewk_view will be better than webview. + + 3) Browser_Window::window -> Browser_Window::elm_window + The name is changed to be distinguished with 'Browser_Window *window' + + 4) browser_{window|view}_find() -> window_find_with_{elm_window|ewk_view}() + This is changed because the name of the function can be confused. + Currently, browser_window_find() returns Browser_Window*. And + browser_view_find() also returns Browser_Window*. + + 5) FileSelectorData -> File_Selector_Data / AuthData -> Auth_Data + The type definition is moved to the top of the source file + and the name is changed to follow EFL style. + + * MiniBrowser/efl/main.c: + (miniBrowserViewSmartClass): + (_Browser_Window): + (_File_Selector_Data): + (_Auth_Data): + (window_find_with_ewk_view): + (window_free): + (on_key_down): + (view_focus_set): + (on_mouse_down): + (title_set): + (on_title_changed): + (on_url_changed): + (on_back_forward_list_changed): + (on_new_window): + (on_close_window): + (on_progress): + (on_error): + (on_download_request): + (close_file_picker): + (on_filepicker_parent_deletion): + (on_filepicker_deletion): + (on_fileselector_done): + (on_file_chooser_request): + (on_download_finished): + (on_download_failed): + (on_favicon_received): + (on_view_icon_changed): + (on_url_bar_activated): + (on_url_bar_clicked): + (on_back_button_clicked): + (on_forward_button_clicked): + (on_refresh_button_clicked): + (on_javascript_alert): + (on_javascript_confirm): + (on_javascript_prompt): + (on_window_geometry_get): + (on_window_geometry_set): + (on_fullscreen_deny): + (on_fullscreen_enter): + (on_fullscreen_exit): + (auth_popup_close): + (on_auth_cancel): + (on_auth_ok): + (on_authentication_request): + (on_tooltip_text_set): + (on_tooltip_text_unset): + (on_home_button_clicked): + (on_window_deletion): + (window_create): + +2012-11-14 Thiago Marcos P. Santos <thiago.santos@intel.com> + + webkitpy: Update the EFL list of bots + https://bugs.webkit.org/show_bug.cgi?id=102121 + + Reviewed by Kenneth Rohde Christiansen. + + Update the EFL bots so we can use garden-o-matic. + + * Scripts/webkitpy/layout_tests/port/builders.py: + +2012-11-13 Yael Aharon <yael.aharon@intel.com> + + [EFL][WK2] New window size should consult the window attributes + https://bugs.webkit.org/show_bug.cgi?id=102122 + + Reviewed by Kenneth Rohde Christiansen. + + Take into account the size that was specified in window.open + when creating a new window. This avoids ugly flashing on the screen. + + * MiniBrowser/efl/main.c: + (on_key_down): + (on_new_window): + (window_create): + (elm_main): + +2012-11-13 Dana Jansens <danakj@chromium.org> + + [chromium] Plumb WebCompositorSupport settings through WebLayerTreeSettings as well, in preparation for removing the settings from WebCompositorSupport + https://bugs.webkit.org/show_bug.cgi?id=102146 + + Reviewed by James Robinson. + + Pass settings that go through WebCompositorSupport also through + WebLayerTreeSettings. When the compositor starts using those instead, + we can remove the callers to the WebCompositorSupport setters. + + * DumpRenderTree/chromium/TestShell.cpp: + (TestShell::TestShell): + (TestShell::resetWebSettings): + (TestShell::setPerTilePaintingEnabled): + (TestShell::setAcceleratedAnimationEnabled): + * DumpRenderTree/chromium/TestShell.h: + (TestShell): + * DumpRenderTree/chromium/WebPreferences.cpp: + (WebPreferences::applyTo): + * DumpRenderTree/chromium/WebPreferences.h: + (WebPreferences): + +2012-11-13 Kentaro Hara <haraken@chromium.org> + + Unreviewed, rolling out r134503. + http://trac.webkit.org/changeset/134503 + + Roll out a patch that was landed just to investigate svn + trouble + + * Scripts/webkitpy/common/config/committers.py: + +2012-11-13 Kentaro Hara <haraken@chromium.org> + + Unreviewed. Investigating svn trouble. Test commit. + + * Scripts/webkitpy/common/config/committers.py: + +2012-11-13 Dimitri Glazkov <dglazkov@chromium.org> + + Unreviewed, rolling out r134446. + http://trac.webkit.org/changeset/134446 + https://bugs.webkit.org/show_bug.cgi?id=101968 + + Need to try a different strategy for landing a two-sided patch + (3/3). + + * DumpRenderTree/chromium/TestShell.cpp: + (TestShell::TestShell): + (TestShell::resetWebSettings): + (TestShell::setPerTilePaintingEnabled): + (TestShell::setAcceleratedAnimationEnabled): + * DumpRenderTree/chromium/TestShell.h: + (TestShell): + * DumpRenderTree/chromium/WebPreferences.cpp: + (WebPreferences::applyTo): + * DumpRenderTree/chromium/WebPreferences.h: + (WebPreferences): + +2012-11-13 Dimitri Glazkov <dglazkov@chromium.org> + + Unreviewed, rolling out r134449. + http://trac.webkit.org/changeset/134449 + https://bugs.webkit.org/show_bug.cgi?id=102076 + + Re-rolling in the patch, it was innocent. + + * TestWebKitAPI/PlatformEfl.cmake: + +2012-11-13 Dimitri Glazkov <dglazkov@chromium.org> + + Unreviewed, rolling out r134424. + http://trac.webkit.org/changeset/134424 + https://bugs.webkit.org/show_bug.cgi?id=102076 + + Made fast/dom/Window/open-window-min-size.html crash. + + * TestWebKitAPI/PlatformEfl.cmake: + +2012-11-12 Dana Jansens <danakj@chromium.org> + + [chromium] Remove the WebCompositorSupport methods for changing settings, plumb everything through WebLayerTreeSettings + https://bugs.webkit.org/show_bug.cgi?id=101968 + + Reviewed by James Robinson. + + * DumpRenderTree/chromium/TestShell.cpp: + (TestShell::TestShell): + (TestShell::resetWebSettings): + * DumpRenderTree/chromium/TestShell.h: + (TestShell::setPerTilePaintingEnabled): + (TestShell::setAcceleratedAnimationEnabled): + (TestShell): + * DumpRenderTree/chromium/WebPreferences.cpp: + (WebPreferences::applyTo): + * DumpRenderTree/chromium/WebPreferences.h: + (WebPreferences): + +2012-11-13 Dirk Pranke <dpranke@chromium.org> + + Fix webkitpy issues arising from a partially-installed pylint. + Unreviewed, build fix. + + This patch ensures that we will re-install the pylint and logilab + packages if any of them are missing, not just the pylint package. + + * Scripts/webkitpy/thirdparty/__init__.py: + (AutoinstallImportHook._install_pylint): + +2012-11-13 No'am Rosenthal <noam.rosenthal@nokia.com> + + Unreviewed, adding my new email address to committers.py and watchlist. + + * Scripts/webkitpy/common/config/committers.py: + * Scripts/webkitpy/common/config/watchlist: + +2012-11-13 Raphael Kubo da Costa <raphael.kubo.da.costa@intel.com> + + [CMake] Incorrect dependency calculation when generating forwarding headers + https://bugs.webkit.org/show_bug.cgi?id=102076 + + Reviewed by Kenneth Rohde Christiansen. + + Explicitly call generate-forwarding-headers.pl on ${WEBKIT2_DIR} as + well, since some dependencies pulled in via the WebKit2/WebKit2_C.h + include in config.h are only generated from there. + + This is a bit redundant since this is also done in WebKit2's + PlatformEfl.cmake, however the WTF and WebCore API tests do not depend + on WebKit2 so the script may not have been called when these tests are + being built. + + * TestWebKitAPI/PlatformEfl.cmake: + +2012-11-13 Zeno Albisser <zeno@webkit.org> + + Unreviewed: Adding watchlist definition for CoordinatedGraphics. + + * Scripts/webkitpy/common/config/watchlist: + +2012-11-13 Hugo Parente Lima <hugo.lima@openbossa.org> + + [cmake] Do not use GLOB to add WTR IDL files to buildsystem. + https://bugs.webkit.org/show_bug.cgi?id=101785 + + Reviewed by Caio Marcelo de Oliveira Filho. + + Using *.idl makes impossible to add IDL files depending on compiler flags, + like a possible GamepadController.idl file found on Chromium. + + * WebKitTestRunner/CMakeLists.txt: + +2012-11-13 Jochen Eisinger <jochen@chromium.org> + + [chromium] TestRunner should depend on webkit_wtf_support instead of compiling the files itself + https://bugs.webkit.org/show_bug.cgi?id=102075 + + Reviewed by Pavel Feldman. + + * DumpRenderTree/DumpRenderTree.gyp/DumpRenderTree.gyp: + +2012-11-13 Raphael Kubo da Costa <raphael.kubo.da.costa@intel.com> + + [EFL][DRT] Remove extra layoutFrame() call when preparing to send an event via EventSender. + https://bugs.webkit.org/show_bug.cgi?id=102074 + + Reviewed by Kenneth Rohde Christiansen. + + * DumpRenderTree/efl/EventSender.cpp: + (feedMouseEvent): Do not call DumpRenderTreeSupportEfl::layoutFrame() + when sending an event, as it causes additional repaints that create + wrong pixel results for tests such as + fast/repaint/overflow-auto-in-overflow-auto-scrolled.html. + +2012-11-13 Csaba Osztrogonác <ossy@webkit.org> + + [Qt] Enable Mutation observer + https://bugs.webkit.org/show_bug.cgi?id=102066 + + Reviewed by Pavel Feldman. + + * qmake/mkspecs/features/features.pri: + +2012-11-13 Xiaobo Wang <xbwang@torchmobile.com.cn> + + [BlackBerry] DRT - platform/blackberry/editing/text-iterator/findString-markers.html failed + https://bugs.webkit.org/show_bug.cgi?id=102056 + + Reviewed by Rob Buis. + + RIM PR 235836 + + TestRunner::findString() was changed to call Page::findString() instead + of WebPage::findNextString(). Page::findString() doesn't update + TextMatch markers. + Work-around by calling both Page::findString() and WebPage::findNextString(). + + * DumpRenderTree/blackberry/TestRunnerBlackBerry.cpp: + (TestRunner::findString): + +2012-11-12 Jochen Eisinger <jochen@chromium.org> + + Add the TestRunner public API to the ChromiumPublicApi watchlist, and introduce an entry for ChromiumTestRunner + https://bugs.webkit.org/show_bug.cgi?id=101957 + + Reviewed by Adam Barth. + + Chromium now also depends on the TestRunner public API, and as such, similar rules as for the Chromium WebKit API should apply. + + * Scripts/webkitpy/common/config/watchlist: + +2012-11-13 Jochen Eisinger <jochen@chromium.org> + + [chromium] move tracking of damaged regions from WebViewHost to WebTestProxy + https://bugs.webkit.org/show_bug.cgi?id=101927 + + Reviewed by Adam Barth. + + This will allow for sharing the code with content_shell + + * DumpRenderTree/chromium/DRTTestRunner.cpp: + (DRTTestRunner::display): + * DumpRenderTree/chromium/TestRunner/public/WebTestProxy.h: + (WebKit): + (WebTestProxyBase): + (WebTestRunner::WebTestProxy::didInvalidateRect): + (WebTestRunner::WebTestProxy::didScrollRect): + (WebTestRunner::WebTestProxy::scheduleComposite): + (WebTestRunner::WebTestProxy::scheduleAnimation): + (WebTestRunner::WebTestProxy::setWindowRect): + (WebTestRunner::WebTestProxy::show): + (WebTestRunner::WebTestProxy::didAutoResize): + (WebTestRunner::WebTestProxy::postAccessibilityNotification): + * DumpRenderTree/chromium/TestRunner/src/WebTestProxy.cpp: + (WebTestRunner::WebTestProxyBase::setPaintRect): + (WebTestRunner): + (WebTestRunner::WebTestProxyBase::paintRect): + (WebTestRunner::WebTestProxyBase::didInvalidateRect): + (WebTestRunner::WebTestProxyBase::didScrollRect): + (WebTestRunner::WebTestProxyBase::scheduleComposite): + (WebTestRunner::WebTestProxyBase::scheduleAnimation): + (WebTestRunner::WebTestProxyBase::show): + (WebTestRunner::WebTestProxyBase::setWindowRect): + (WebTestRunner::WebTestProxyBase::didAutoResize): + (WebTestRunner::WebTestProxyBase::postAccessibilityNotification): + * DumpRenderTree/chromium/TestShell.cpp: + (TestShell::createNewWindow): + * DumpRenderTree/chromium/WebViewHost.cpp: + (WebViewHost::scheduleAnimation): + (WebViewHost::show): + (WebViewHost::setWindowRect): + (WebViewHost::WebViewHost): + (WebViewHost::proxy): + (WebViewHost::setProxy): + (WebViewHost::reset): + (WebViewHost::paintInvalidatedRegion): + * DumpRenderTree/chromium/WebViewHost.h: + (WebViewHost): + +2012-11-12 Dirk Pranke <dpranke@chromium.org> + + webkitpy: clean up lint errors, part 1 + https://bugs.webkit.org/show_bug.cgi?id=102024 + + Reviewed by Adam Barth. + + This patch cleans up a lot of miscellaneous minor lint errors that + apparently aren't caught by unit tests, and suppresses a few + false positives. + + Also, this patch removes the garden-o-matic "rollout" entry point + since it's no longer being used by the frontend (rather than + fix it to not generate lint errors). + + * Scripts/webkitpy/common/system/executive_mock.py: + (MockExecutive2.run_command): + * Scripts/webkitpy/common/system/filesystem_mock.py: + (MockFileSystem.copyfile): + * Scripts/webkitpy/layout_tests/controllers/manager.py: + (Manager._http_tests): + * Scripts/webkitpy/layout_tests/port/apple.py: + (ApplePort): + * Scripts/webkitpy/layout_tests/port/base.py: + (Port.reference_files): + * Scripts/webkitpy/layout_tests/port/chromium.py: + (ChromiumPort): + * Scripts/webkitpy/layout_tests/port/chromium_android.py: + (ChromiumAndroidDriver._teardown_performance): + * Scripts/webkitpy/layout_tests/port/chromium_port_testcase.py: + (ChromiumPortTestCase.TestAndroidPort.__init__): + (ChromiumPortTestCase.test_default_configuration): + * Scripts/webkitpy/layout_tests/port/port_testcase.py: + (PortTestCase): + (PortTestCase.test_driver_cmd_line): + (PortTestCase.test_expectations_ordering): + * Scripts/webkitpy/layout_tests/servers/http_server_base.py: + (HttpServerBase._check_that_all_ports_are_available): + * Scripts/webkitpy/style/checkers/python.py: + (Pylinter): + * Scripts/webkitpy/tool/commands/gardenomatic.py: + (GardenOMatic.__init__): + * Scripts/webkitpy/tool/commands/queues.py: + (CommitQueue): + * Scripts/webkitpy/tool/servers/gardeningserver.py: + (GardeningHTTPRequestHandler): + (GardeningHTTPRequestHandler.localresult): + +2012-11-12 Dirk Pranke <dpranke@chromium.org> + + webkitpy: clean up lint errors, part 2 + https://bugs.webkit.org/show_bug.cgi?id=102029 + + Reviewed by Adam Barth. + + This cleans up the remaining lint errors in webkitpy with four exceptions: + 1) we don't lint thirdparty/ autoinstalled code, obviously + 2) there's an intentional error in the unit tests for pylint itself + 3) the implementation of webkit-patch optimize-expectations has + an error but I think we can and should just remove that command as well. + 4) I have not yet linted the test code + + * Scripts/webkitpy/common/newstringio.py: + * Scripts/webkitpy/common/checkout/scm/scm.py: + (SCM.find_checkout_root): + (SCM.will.remote_merge_base): + * Scripts/webkitpy/common/checkout/scm/scm_mock.py: + * Scripts/webkitpy/common/checkout/scm/svn.py: + (SVNRepository.has_authorization_for_realm): + (SVN.__init__): + * Scripts/webkitpy/common/config/contributionareas.py: + (ContributionAreas.names): + * Scripts/webkitpy/common/config/ports.py: + (DeprecatedPort): + * Scripts/webkitpy/common/net/buildbot/buildbot.py: + (Builder.force_build): + * Scripts/webkitpy/common/net/buildbot/buildbot_mock.py: + * Scripts/webkitpy/style/checkers/cpp.py: + (check_posix_threading): + (check_spacing): + * Scripts/webkitpy/style/optparser.py: + (ArgumentParser._create_option_parser): + * Scripts/webkitpy/tool/commands/abstractlocalservercommand.py: + (AbstractLocalServerCommand.execute): + * Scripts/webkitpy/tool/commands/download.py: + (AbstractPatchProcessingCommand): + (AbstractPatchProcessingCommand._process_patch): + * Scripts/webkitpy/tool/commands/earlywarningsystem.py: + (AbstractEarlyWarningSystem): + +2012-11-12 Dirk Pranke <dpranke@chromium.org> + + remove 'webkit-patch optimize-expectations' + https://bugs.webkit.org/show_bug.cgi?id=102032 + + Reviewed by Adam Barth. + + Removing this command because it is totally broken (probably + broke when I added support for multiple files in a cascade) + and doesn't seem to do anything much useful. It certainly + didn't actually optimize things. + + * Scripts/webkitpy/tool/commands/expectations.py: Removed. + +2012-11-12 Xiaobo Wang <xbwang@torchmobile.com.cn> + + [BlackBerry] DRT - Update Pixel Dump Support for OpenGL renderer + https://bugs.webkit.org/show_bug.cgi?id=101894 + + Reviewed by Rob Buis. + + RIM PR 241686 + Also remove an un-needed pixel lock, and fix a klocwork error in SKIA + code path. + + * DumpRenderTree/blackberry/PixelDumpSupportBlackBerry.cpp: + (readPixelsUserInterfaceThread): + (createBitmapContextFromWebView): + +2012-11-12 Daniel Bates <dbates@webkit.org> + + Perl errors from Tools/Scripts/copy-webkitlibraries-to-product-directory + https://bugs.webkit.org/show_bug.cgi?id=101980 + + Reviewed by Mark Rowe. + + Remove library libWebKitSystemInterfaceLeopard.a and libWebKitSystemInterfaceSnowLeopard.a + from the list of libraries to copy to the specified built products directory + as these libraries were removed from the repository in <http://trac.webkit.org/changeset/133670>. + + * Scripts/copy-webkitlibraries-to-product-directory: + +2012-11-12 Dirk Pranke <dpranke@chromium.org> + + webkitpy: integrate pylint into check-webkit-style, part I + https://bugs.webkit.org/show_bug.cgi?id=101285 + + Reviewed by Ojan Vafai. + + This patch re-works lint-webkitpy so that the logic is pushed + into check-webkit-style (mostly); we don't yet control which + messages are displayed using the rules in webkitpy/style/checker.py + (we're still using the pylintrc to suppress messages instead), + but otherwise things work. For now we will only report pylint + "errors", not warnings. + + * Scripts/lint-webkitpy: + * Scripts/webkitpy/style/checker.py: + * Scripts/webkitpy/style/checkers/python.py: + (PythonChecker): + (PythonChecker.check): + (PythonChecker._check_pep8): + (PythonChecker._check_pylint): + (Pylinter): + (Pylinter.__init__): + (Pylinter.run): + (_FilteredStringIO): + (_FilteredStringIO.__init__): + (_FilteredStringIO.write): + (_FilteredStringIO._filter): + * Scripts/webkitpy/style/checkers/python_unittest.py: + (PythonCheckerTest.test_check): + * Scripts/webkitpy/style/checkers/python_unittest_input.py: + +2012-11-12 Dirk Pranke <dpranke@chromium.org> + + nrwt: remove a bunch of broken chromium-specific flags + https://bugs.webkit.org/show_bug.cgi?id=101979 + + Reviewed by Tony Chang. + + There were a bunch of chromium-specific flags that used to be + supported by NRWT (and handled and passed on to DRT) but have + probably been broken for a long time and are currently ignored. + + This patch removes all of those flags; the rule of thumb going forward + is that we should only add flags that affect how the python code functions. + If a flag is just passed verbatim to DRT, the user can use --additional-drt-flag + for that. + + * Scripts/webkitpy/layout_tests/run_webkit_tests.py: + (parse_args): + * Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py: + (MainTest.setUp): + +2012-11-12 Mikhail Pozdnyakov <mikhail.pozdnyakov@intel.com> + + [EFL][WK2] Add --device-pixel-ratio command line option to EFL MiniBrowser + https://bugs.webkit.org/show_bug.cgi?id=101930 + + Reviewed by Kenneth Rohde Christiansen. + + Added --device-pixel-ratio command line option to EFL MiniBrowser which sets + the ratio between the CSS units and device pixels when the content is unscaled. + Option is applied for all the views created by mini browser. + + * MiniBrowser/efl/main.c: + (window_create): + (elm_main): + +2012-11-12 Dirk Pranke <dpranke@chromium.org> + + remove the chromium-mac-mountainlion TestExpectations file + https://bugs.webkit.org/show_bug.cgi?id=101789 + + Reviewed by Ojan Vafai. + + Nearly all of the tests have been updated for 10.8 and the remaining + failures have been merged into the main TestExpectations file. We + don't need this hook any more. + + * Scripts/webkitpy/layout_tests/port/chromium_mac.py: + (ChromiumMacPort.operating_system): + * Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py: + (ChromiumMacPortTest.test_path_to_image_diff): + +2012-11-12 Peter Beverloo <peter@chromium.org> + + [Chromium-Android] Restart the device's shell in root before pushing data + https://bugs.webkit.org/show_bug.cgi?id=101944 + + Reviewed by Adam Barth. + + Setting up md5sum and pushing the executable, fonts and test resources was + unintentionally being done prior to executing the "adb root" command, + which restarts the device's shell to be root. Since test data is still + being pushed to /data/local/tmp, writing to which requires root access, + devices not running as root would throw a ScriptError. + + * Scripts/webkitpy/layout_tests/port/chromium_android.py: + (ChromiumAndroidDriver._setup_test): + +2012-11-12 Allan Sandfeld Jensen <allan.jensen@digia.com> + + [Qt] Support ResourceRequest's setTimeoutInterval + https://bugs.webkit.org/show_bug.cgi?id=101731 + + Reviewed by Simon Hausmann. + + Enable XHR_TIMEOUT now that we support the necessary feature. + + * qmake/mkspecs/features/features.pri: + +2012-11-12 Gustavo Noronha Silva <gns@gnome.org> + + Unreviewed. Removing myself from the list of address to CC on EWS + build failure; the CC turned out to just be too noisy so I'm + tracking those in a different way. + + * Scripts/webkitpy/tool/commands/earlywarningsystem.py: + (GtkEWS): + +2012-11-12 Allan Sandfeld Jensen <allan.jensen@digia.com> + + [Qt] Can not load MHTML documents + https://bugs.webkit.org/show_bug.cgi?id=101765 + + Reviewed by Simon Hausmann. + + Enable MHTML feature. + + * qmake/mkspecs/features/features.pri: + +2012-11-12 Tommy Widenflycht <tommyw@google.com> + + MediaStream API: Schedule the RTCDataChannel events to be triggered at idle state + https://bugs.webkit.org/show_bug.cgi?id=101751 + + Reviewed by Adam Barth. + + Makes the data channel mocks to be synchronous instead of asynchronous to be able to + properly test RTCDataChannel event handling. + + * DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp: + (MockWebRTCPeerConnectionHandler::sendStringData): + (MockWebRTCPeerConnectionHandler::sendRawData): + +2012-11-12 Jochen Eisinger <jochen@chromium.org> + + [chromium] move TestRunner implementation into WebTestRunner namespace + https://bugs.webkit.org/show_bug.cgi?id=101837 + + Reviewed by Adam Barth. + + That way, we don't get collisions when linking e.g. against chromium's + net test support library. + + * DumpRenderTree/chromium/DRTTestRunner.h: + (DRTTestRunner): + * DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.h: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/AccessibilityUIElementChromium.cpp: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/AccessibilityUIElementChromium.h: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/CppBoundClass.cpp: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/CppBoundClass.h: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/CppVariant.cpp: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/CppVariant.h: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/EventSender.h: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/GamepadController.cpp: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/GamepadController.h: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/TestDelegate.h: + (WebTestRunner): + (TestDelegate): + * DumpRenderTree/chromium/TestRunner/src/TestInterfaces.cpp: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/TestInterfaces.h: + (WebTestRunner): + (TestInterfaces): + * DumpRenderTree/chromium/TestRunner/src/TestRunner.cpp: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/TestRunner.h: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/TextInputController.cpp: + (WebTestRunner): + * DumpRenderTree/chromium/TestRunner/src/TextInputController.h: + (WebTestRunner): + +2012-11-12 Zeno Albisser <zeno@webkit.org> + + [Qt] MiniBrowser should not strongly depend on QtTestSupport. + https://bugs.webkit.org/show_bug.cgi?id=101775 + + Introducing HAVE(QTTESTSUPPORT) to allow building + MiniBrowser without QtTestSupport. + This is necessary when using a production build. + + Reviewed by Tor Arne Vestbø. + + * MiniBrowser/qt/MiniBrowserApplication.cpp: + (MiniBrowserApplication::handleUserOptions): + * qmake/mkspecs/features/configure.prf: + * qmake/mkspecs/features/features.prf: + +2012-11-11 Kangil Han <kangil.han@samsung.com> + + Change build congratulation message in EFL + https://bugs.webkit.org/show_bug.cgi?id=101833 + + Reviewed by Gyuyoung Kim. + + EFL port is currently supporting both WK1 and WK2. + But, build congratulation message still shows WK1(EWebLauncher) only. + Therefore, this patch adopts WK2 reference execution(MiniBrowser) in its message. + + From 'To run EWebLauncher with this newly-built code, use the' + to 'To run EWebLauncher/MiniBrowser with this newly-built code, use the'. + + * Scripts/build-webkit: + (writeCongrats): + * Scripts/webkitdirs.pm: + (launcherName): + +2012-11-09 Ryosuke Niwa <rniwa@webkit.org> + + People with dichromacy can't tell crashes and passes on flakiness dashboard + https://bugs.webkit.org/show_bug.cgi?id=101711 + + Reviewed by Ojan Vafai. + + Lower the brightness of orange, and raise the brightness of green so that + people with color blindnes can still distinguish passes and crashes easily. + + * TestResultServer/static-dashboards/flakiness_dashboard_tests.css: + (.P): + (.C): + +2012-11-09 Tommy Widenflycht <tommyw@google.com> + + MediaStream API: Deleting all files relating to the deprecated PeerConnection00 + https://bugs.webkit.org/show_bug.cgi?id=101730 + + Reviewed by Adam Barth. + + Since RTCPeerConenction has superseeded PeerConnection00 this patch removes all + files relating to the old API. + + * DumpRenderTree/chromium/MockWebMediaStreamCenter.cpp: + * DumpRenderTree/chromium/MockWebMediaStreamCenter.h: + (MockWebMediaStreamCenter): + * DumpRenderTree/chromium/TestShell.cpp: + (TestShell::TestShell): + +2012-11-09 Yael Aharon <yael.aharon@intel.com> + + [EFL] Give the view a size in TestWebKitAPI + https://bugs.webkit.org/show_bug.cgi?id=101770 + + Reviewed by Laszlo Gombos. + + 2 tests are currently failing, because they expect us to paint, but we don't paint if the view size is empty. + + * TestWebKitAPI/efl/PlatformWebView.cpp: + (TestWebKitAPI::PlatformWebView::PlatformWebView): + (TestWebKitAPI::PlatformWebView::~PlatformWebView): + (TestWebKitAPI): + (TestWebKitAPI::PlatformWebView::resizeTo): + +2012-11-09 Sheriff Bot <webkit.review.bot@gmail.com> + + Unreviewed, rolling out r134068. + http://trac.webkit.org/changeset/134068 + https://bugs.webkit.org/show_bug.cgi?id=101766 + + Caused crashes on the bots. (Requested by rakuco on #webkit). + + * WebKitTestRunner/cairo/TestInvocationCairo.cpp: + (WTR::TestInvocation::dumpPixelsAndCompareWithExpected): + +2012-11-09 Zan Dobersek <zandobersek@gmail.com> + + [GTK] Bump the jhbuild Cairo version to 1.12.8 + https://bugs.webkit.org/show_bug.cgi?id=101721 + + Bump the Cairo version in Jhbuild moduleset to 1.12.8. This version + should fix multiple failures in canvas tests and also contains + fixes for X-related crashes that occurred from the 1.12.4 version onwards. + + * gtk/jhbuild.modules: + +2012-11-09 Raphael Kubo da Costa <raphael.kubo.da.costa@intel.com> + + [WTR][Cairo] Do not call paintRepaintRectOverlay() when there is no repaint rect. + https://bugs.webkit.org/show_bug.cgi?id=101759 + + Reviewed by Kenneth Rohde Christiansen. + + * WebKitTestRunner/cairo/TestInvocationCairo.cpp: + (WTR::TestInvocation::dumpPixelsAndCompareWithExpected): Improve + the check for an empty repaintRect -- we need to check if the + WKArrayRef has any items. `if (repaintRect)' will return true + regardless of whether the array is empty or not. + + +2012-11-09 Tor Arne Vestbø <tor.arne.vestbo@digia.com> + + [Qt] Stop watchlist from triggering QtBuildSystem rule on DerivedSources + + Having DerivedSources.pri in the watchlist regexp was creating too much + noise. + + Reviewed by Ossy. + + * Scripts/webkitpy/common/config/watchlist: + +2012-11-09 Dominik Röttsches <dominik.rottsches@intel.com> + + webkitpy/layouttests integration test fails if high shards/processes environment variables are used + https://bugs.webkit.org/show_bug.cgi?id=101455 + + Reviewed by Dirk Pranke. + + Updating test to disregard WEBKIT_TEST_MAX_LOCKED_SHARDS environment variable. + + * Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py: + (MainTest.test_max_locked_shards): + +2012-11-09 Raphael Kubo da Costa <raphael.kubo.da.costa@intel.com> + + [EFL][DRT] Force a repaint before tracking repaint rects. + https://bugs.webkit.org/show_bug.cgi?id=101743 + + Reviewed by Kenneth Rohde Christiansen. + + Do like other ports and force a repaint before we start tracking + repaints so that the pixel results generated look more in line + with what's expected. + + * DumpRenderTree/efl/DumpRenderTree.cpp: + (displayWebView): Call DRTSupport::forceLayout() before start + tracking repaints. + +2012-11-09 Xiaobo Wang <xbwang@torchmobile.com.cn> + + [BlackBerry] DRT - eventSender.keyDown() needs to support pageUp, pageDown, home, end key + https://bugs.webkit.org/show_bug.cgi?id=100937 + + Reviewed by Rob Buis. + + 1. Translate these keys to their corresponding BlackBerry key code. + 2. Break down a KeyChar event to a KeyDown/KeyUp pair. This is required + because we only handle scrolling on a KeyDown event in WebPage::keyEvent() + , and internally a KeyChar event is interpreted as a KeyDown event + a + KeyUp event in InputHandler::handleKeyboardInput(). + + Tests fixed: + 1. editing/input/scroll-viewport-page-up-down.html + 2. editing/selection/move-begin-end.html + 3. fast/forms/select-popup-pagekeys.html + + * DumpRenderTree/blackberry/EventSender.cpp: + (keyDownCallback): + +2012-11-09 Simon Hausmann <simon.hausmann@digia.com> + + Unreviewed prospective Qt/Windows build bot fix: + + Make determination of qmake mkspec work with older versions of Qt that + still create a "mkspecs/default" directory. + + * Scripts/webkitdirs.pm: + (qtMakeCommand): + +2012-11-09 Jochen Eisinger <jochen@chromium.org> + + [chromium] Introduce a WebTestProxy to override methods in WebViewClient for layout tests + https://bugs.webkit.org/show_bug.cgi?id=101452 + + Reviewed by Adam Barth. + + The WebTestProxy is template, so it can derive from an implementation + of the WebViewClient interface. That way, WebTestProxy can hook into + individual methods of the WebViewClient and forward all the rest to the + actual implementation. + + To demonstrate how I want to use this, I moved the + postAccessibilityNotification method from WebViewHost to WebTestProxy. + + * DumpRenderTree/DumpRenderTree.gypi: + * DumpRenderTree/chromium/TestRunner/public/WebTestProxy.h: Added. + (WebKit): + (WebTestRunner): + (WebTestProxyBase): + (WebTestProxy): + (WebTestRunner::WebTestProxy::WebTestProxy): + (WebTestRunner::WebTestProxy::~WebTestProxy): + (WebTestRunner::WebTestProxy::postAccessibilityNotification): + * DumpRenderTree/chromium/TestRunner/src/WebTestProxy.cpp: Added. + (WebTestRunner): + (WebTestRunner::WebTestProxyBase::WebTestProxyBase): + (WebTestRunner::WebTestProxyBase::~WebTestProxyBase): + (WebTestRunner::WebTestProxyBase::setInterfaces): + (WebTestRunner::WebTestProxyBase::setDelegate): + (WebTestRunner::WebTestProxyBase::doPostAccessibilityNotification): + * DumpRenderTree/chromium/TestShell.cpp: + (TestShell::createNewWindow): + * DumpRenderTree/chromium/WebViewHost.cpp: + * DumpRenderTree/chromium/WebViewHost.h: + (WebViewHost): + +2012-11-09 Simon Hausmann <simon.hausmann@digia.com> + + [Qt] Build with MSVC fails to use nmake instead of make + https://bugs.webkit.org/show_bug.cgi?id=98645 + + Reviewed by Tor Arne Vestbø. + + Don't rely on the "default" mkspec but instead query the target + mkspec variable from qmake to find the right qmake.conf. + + * Scripts/webkitdirs.pm: + (qtMakeCommand): + +2012-11-08 Sudarsana Nagineni <sudarsana.nagineni@intel.com> + + [EFL] about:blank should display the blank page + https://bugs.webkit.org/show_bug.cgi?id=101566 + + Reviewed by Laszlo Gombos. + + Add a check to return early without prepending http:// scheme, if the + URL is 'about:blank'. + + * EWebLauncher/url_utils.c: + (url_from_user_input): + +2012-11-08 Christophe Dumez <christophe.dumez@intel.com> + + [EFL][WK2] Add proper support for fullscreen API to MiniBrowser + https://bugs.webkit.org/show_bug.cgi?id=101615 + + Reviewed by Kenneth Rohde Christiansen. + + Implement fullscreen API support in MiniBrowser. When entering + fullscreen a popup is shown to notify the user that something + is displayed in fullscreen and to advertise that the Escape + key can be used to exit fullscreen. This behavior is according + to specification. + + * MiniBrowser/efl/main.c: + (on_key_down): + (on_fullscreen_accept): + (on_fullscreen_deny): + (on_fullscreen_enter): + (on_fullscreen_exit): + (window_create): + 2012-11-08 Slavomir Kaslev <skaslev@google.com> [Chromium] DumpRenderTree fix for canvas in software compositing diff --git a/Tools/DumpRenderTree/DumpRenderTree.gyp/DumpRenderTree.gyp b/Tools/DumpRenderTree/DumpRenderTree.gyp/DumpRenderTree.gyp index 56aeab732..cc8333209 100644 --- a/Tools/DumpRenderTree/DumpRenderTree.gyp/DumpRenderTree.gyp +++ b/Tools/DumpRenderTree/DumpRenderTree.gyp/DumpRenderTree.gyp @@ -83,6 +83,7 @@ 'dependencies': [ 'TestRunner_resources', '<(source_dir)/WebKit/chromium/WebKit.gyp:webkit', + '<(source_dir)/WebKit/chromium/WebKit.gyp:webkit_wtf_support', '<(source_dir)/WebKit/chromium/WebKit.gyp:webkit_test_support', '<(source_dir)/WTF/WTF.gyp/WTF.gyp:wtf', '<(chromium_src_dir)/webkit/support/webkit_support.gyp:webkit_support', @@ -116,12 +117,6 @@ '<(source_dir)/WebKit/chromium/public/gtk', ], }], - ['inside_chromium_build==1 and component=="shared_library"', { - 'sources': [ - '<(source_dir)/WebKit/chromium/src/ChromiumCurrentTime.cpp', - '<(source_dir)/WebKit/chromium/src/ChromiumThreading.cpp', - ], - }], ], }, { diff --git a/Tools/DumpRenderTree/DumpRenderTree.gypi b/Tools/DumpRenderTree/DumpRenderTree.gypi index dd768d049..ac4d2a622 100644 --- a/Tools/DumpRenderTree/DumpRenderTree.gypi +++ b/Tools/DumpRenderTree/DumpRenderTree.gypi @@ -71,6 +71,7 @@ 'chromium/TestRunner/public/WebEventSender.h', 'chromium/TestRunner/public/WebTask.h', 'chromium/TestRunner/public/WebTestInterfaces.h', + 'chromium/TestRunner/public/WebTestProxy.h', 'chromium/TestRunner/src/AccessibilityControllerChromium.cpp', 'chromium/TestRunner/src/AccessibilityControllerChromium.h', 'chromium/TestRunner/src/AccessibilityUIElementChromium.cpp', @@ -95,6 +96,7 @@ 'chromium/TestRunner/src/WebEventSender.cpp', 'chromium/TestRunner/src/WebTask.cpp', 'chromium/TestRunner/src/WebTestInterfaces.cpp', + 'chromium/TestRunner/src/WebTestProxy.cpp', ], 'test_plugin_files': [ 'TestNetscapePlugIn/PluginObject.cpp', diff --git a/Tools/DumpRenderTree/blackberry/EventSender.cpp b/Tools/DumpRenderTree/blackberry/EventSender.cpp index ab7f808f8..0f76914a2 100644 --- a/Tools/DumpRenderTree/blackberry/EventSender.cpp +++ b/Tools/DumpRenderTree/blackberry/EventSender.cpp @@ -131,11 +131,14 @@ static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JS charCode = KEYCODE_UP; else if (JSStringIsEqualToUTF8CString(character, "downArrow")) charCode = KEYCODE_DOWN; - else if (JSStringIsEqualToUTF8CString(character, "pageUp") - || JSStringIsEqualToUTF8CString(character, "pageDown") - || JSStringIsEqualToUTF8CString(character, "home") - || JSStringIsEqualToUTF8CString(character, "end")) - return JSValueMakeUndefined(context); + else if (JSStringIsEqualToUTF8CString(character, "pageUp")) + charCode = KEYCODE_PG_UP; + else if (JSStringIsEqualToUTF8CString(character, "pageDown")) + charCode = KEYCODE_PG_DOWN; + else if (JSStringIsEqualToUTF8CString(character, "home")) + charCode = KEYCODE_HOME; + else if (JSStringIsEqualToUTF8CString(character, "end")) + charCode = KEYCODE_END; else if (JSStringIsEqualToUTF8CString(character, "delete")) charCode = KEYCODE_BACKSPACE; else { @@ -178,7 +181,8 @@ static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JS if (needsCtrlKeyModifier) modifiers |= KEYMOD_CTRL; - page->keyEvent(BlackBerry::Platform::KeyboardEvent(charCode, BlackBerry::Platform::KeyboardEvent::KeyChar, modifiers)); + page->keyEvent(BlackBerry::Platform::KeyboardEvent(charCode, BlackBerry::Platform::KeyboardEvent::KeyDown, modifiers)); + page->keyEvent(BlackBerry::Platform::KeyboardEvent(charCode, BlackBerry::Platform::KeyboardEvent::KeyUp, modifiers)); return JSValueMakeUndefined(context); } @@ -394,8 +398,8 @@ static JSClassRef getClass(JSContextRef context) if (!eventSenderClass) { JSClassDefinition classDefinition = { - 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; classDefinition.staticFunctions = staticFunctions; classDefinition.staticValues = staticValues; diff --git a/Tools/DumpRenderTree/blackberry/PixelDumpSupportBlackBerry.cpp b/Tools/DumpRenderTree/blackberry/PixelDumpSupportBlackBerry.cpp index 420cdfbb8..5a1b89a4c 100644 --- a/Tools/DumpRenderTree/blackberry/PixelDumpSupportBlackBerry.cpp +++ b/Tools/DumpRenderTree/blackberry/PixelDumpSupportBlackBerry.cpp @@ -20,6 +20,11 @@ #include "PixelDumpSupportBlackBerry.h" #include "BackingStore.h" +#include "BlackBerryPlatformExecutableMessage.h" +#include "BlackBerryPlatformGraphics.h" +#include "BlackBerryPlatformGraphicsContext.h" +#include "BlackBerryPlatformGraphicsImpl.h" +#include "BlackBerryPlatformMessageClient.h" #include "DumpRenderTreeBlackBerry.h" #include "PNGImageEncoder.h" #include "PixelDumpSupport.h" @@ -37,6 +42,11 @@ using namespace BlackBerry::WebKit; using namespace BlackBerry; using namespace WTF; +void readPixelsUserInterfaceThread(BlackBerry::Platform::Graphics::PlatformGraphicsContext* context, const BlackBerry::Platform::IntRect& srcRect, unsigned char* pixels) +{ + context->readPixels(srcRect, pixels, false, false); +} + PassRefPtr<BitmapContext> createBitmapContextFromWebView(bool /*onscreen*/, bool /*incrementalRepaint*/, bool /*sweepHorizontally*/, bool /*drawSelectionRect*/) { Platform::Graphics::Window* window = DumpRenderTree::currentInstance()->page()->client()->window(); @@ -71,14 +81,21 @@ PassRefPtr<BitmapContext> createBitmapContextFromWebView(bool /*onscreen*/, bool const unsigned char* windowPixels = 0; if (!contentsBitmap.empty()) { - SkAutoLockPixels lock(contentsBitmap); windowPixels = static_cast<const unsigned char*>(contentsBitmap.getPixels()); + if (windowPixels) + memcpy(data, windowPixels, windowSize.width() * windowSize.height() * 4); } #else - const unsigned char* windowPixels = lockBufferBackingImage(window->buffer(), Platform::Graphics::ReadAccess); + BlackBerry::Platform::Graphics::Buffer* buffer = BlackBerry::Platform::Graphics::createBuffer(windowSize, BlackBerry::Platform::Graphics::TemporaryBuffer); + BlackBerry::Platform::Graphics::Drawable* drawable = BlackBerry::Platform::Graphics::lockBufferDrawable(buffer); + if (drawable) { + backingStore->drawContents(drawable, windowRect, windowSize); + BlackBerry::Platform::userInterfaceThreadMessageClient()->dispatchSyncMessage( + BlackBerry::Platform::createFunctionCallMessage(&readPixelsUserInterfaceThread, drawable, windowRect, data)); + BlackBerry::Platform::Graphics::releaseBufferDrawable(buffer); + } + BlackBerry::Platform::Graphics::destroyBuffer(buffer); #endif - memcpy(data, windowPixels, windowSize.width() * windowSize.height() * 4); - Platform::Graphics::releaseBufferBackingImage(window->buffer()); return BitmapContext::createByAdoptingData(data, windowSize.width(), windowSize.height()); } diff --git a/Tools/DumpRenderTree/blackberry/TestRunnerBlackBerry.cpp b/Tools/DumpRenderTree/blackberry/TestRunnerBlackBerry.cpp index c80a96ddb..f06f4a84c 100644 --- a/Tools/DumpRenderTree/blackberry/TestRunnerBlackBerry.cpp +++ b/Tools/DumpRenderTree/blackberry/TestRunnerBlackBerry.cpp @@ -402,7 +402,7 @@ unsigned TestRunner::numberOfActiveAnimations() const return animationController->numberOfActiveAnimations(mainFrame->document()); } -unsigned int TestRunner::workerThreadCount() const +unsigned TestRunner::workerThreadCount() const { #if ENABLE_WORKERS return WebCore::WorkerThread::workerThreadCount(); @@ -538,17 +538,17 @@ void TestRunner::setSpatialNavigationEnabled(bool enable) void TestRunner::addOriginAccessWhitelistEntry(JSStringRef sourceOrigin, JSStringRef destinationProtocol, JSStringRef destinationHost, bool allowDestinationSubdomains) { WebCore::SecurityPolicy::addOriginAccessWhitelistEntry(*WebCore::SecurityOrigin::createFromString(jsStringRefToWebCoreString(sourceOrigin)), - jsStringRefToWebCoreString(destinationProtocol), - jsStringRefToWebCoreString(destinationHost), - allowDestinationSubdomains); + jsStringRefToWebCoreString(destinationProtocol), + jsStringRefToWebCoreString(destinationHost), + allowDestinationSubdomains); } void TestRunner::removeOriginAccessWhitelistEntry(JSStringRef sourceOrigin, JSStringRef destinationProtocol, JSStringRef destinationHost, bool allowDestinationSubdomains) { WebCore::SecurityPolicy::removeOriginAccessWhitelistEntry(*WebCore::SecurityOrigin::createFromString(jsStringRefToWebCoreString(sourceOrigin)), - jsStringRefToWebCoreString(destinationProtocol), - jsStringRefToWebCoreString(destinationHost), - allowDestinationSubdomains); + jsStringRefToWebCoreString(destinationProtocol), + jsStringRefToWebCoreString(destinationHost), + allowDestinationSubdomains); } void TestRunner::setAllowFileAccessFromFileURLs(bool enabled) @@ -752,6 +752,13 @@ bool TestRunner::findString(JSContextRef context, JSStringRef target, JSObjectRe options |= WebCore::StartInSelection; } + // FIXME: we don't need to call WebPage::findNextString(), this is a workaround + // so that test platform/blackberry/editing/text-iterator/findString-markers.html can pass. + + // Our layout tests assume find will wrap and highlight all matches. + BlackBerry::WebKit::DumpRenderTree::currentInstance()->page()->findNextString(nameStr.utf8().data(), + !(options & WebCore::Backwards), !(options & WebCore::CaseInsensitive), true /* wrap */, true /* highlightAllMatches */); + return mainFrame->page()->findString(nameStr, options); } diff --git a/Tools/DumpRenderTree/chromium/DRTTestRunner.cpp b/Tools/DumpRenderTree/chromium/DRTTestRunner.cpp index dafafa181..2f8397bee 100644 --- a/Tools/DumpRenderTree/chromium/DRTTestRunner.cpp +++ b/Tools/DumpRenderTree/chromium/DRTTestRunner.cpp @@ -111,7 +111,6 @@ DRTTestRunner::DRTTestRunner(TestShell* shell) // they will use when called by JavaScript. The actual binding of those // names to their methods will be done by calling bindToJavaScript() (defined // by CppBoundClass, the parent to DRTTestRunner). - bindMethod("addFileToPasteboardOnDrag", &DRTTestRunner::addFileToPasteboardOnDrag); #if ENABLE(INPUT_SPEECH) bindMethod("addMockSpeechInputResult", &DRTTestRunner::addMockSpeechInputResult); bindMethod("setMockSpeechInputDumpRect", &DRTTestRunner::setMockSpeechInputDumpRect); @@ -121,9 +120,6 @@ DRTTestRunner::DRTTestRunner(TestShell* shell) bindMethod("setMockSpeechRecognitionError", &DRTTestRunner::setMockSpeechRecognitionError); bindMethod("wasMockSpeechRecognitionAborted", &DRTTestRunner::wasMockSpeechRecognitionAborted); #endif - bindMethod("addOriginAccessWhitelistEntry", &DRTTestRunner::addOriginAccessWhitelistEntry); - bindMethod("addUserScript", &DRTTestRunner::addUserScript); - bindMethod("addUserStyleSheet", &DRTTestRunner::addUserStyleSheet); bindMethod("clearAllDatabases", &DRTTestRunner::clearAllDatabases); bindMethod("closeWebInspector", &DRTTestRunner::closeWebInspector); #if ENABLE(POINTER_LOCK) @@ -132,14 +128,12 @@ DRTTestRunner::DRTTestRunner(TestShell* shell) bindMethod("didNotAcquirePointerLock", &DRTTestRunner::didNotAcquirePointerLock); #endif bindMethod("disableAutoResizeMode", &DRTTestRunner::disableAutoResizeMode); - bindMethod("disableImageLoading", &DRTTestRunner::disableImageLoading); bindMethod("display", &DRTTestRunner::display); bindMethod("displayInvalidatedRegion", &DRTTestRunner::displayInvalidatedRegion); bindMethod("dumpAsText", &DRTTestRunner::dumpAsText); bindMethod("dumpBackForwardList", &DRTTestRunner::dumpBackForwardList); bindMethod("dumpChildFramesAsText", &DRTTestRunner::dumpChildFramesAsText); bindMethod("dumpChildFrameScrollPositions", &DRTTestRunner::dumpChildFrameScrollPositions); - bindMethod("dumpDatabaseCallbacks", &DRTTestRunner::dumpDatabaseCallbacks); bindMethod("dumpEditingCallbacks", &DRTTestRunner::dumpEditingCallbacks); bindMethod("dumpFrameLoadCallbacks", &DRTTestRunner::dumpFrameLoadCallbacks); bindMethod("dumpProgressFinishedCallback", &DRTTestRunner::dumpProgressFinishedCallback); @@ -151,34 +145,15 @@ DRTTestRunner::DRTTestRunner(TestShell* shell) bindMethod("dumpTitleChanges", &DRTTestRunner::dumpTitleChanges); bindMethod("dumpPermissionClientCallbacks", &DRTTestRunner::dumpPermissionClientCallbacks); bindMethod("dumpCreateView", &DRTTestRunner::dumpCreateView); - bindMethod("elementDoesAutoCompleteForElementWithId", &DRTTestRunner::elementDoesAutoCompleteForElementWithId); bindMethod("enableAutoResizeMode", &DRTTestRunner::enableAutoResizeMode); bindMethod("evaluateInWebInspector", &DRTTestRunner::evaluateInWebInspector); - bindMethod("evaluateScriptInIsolatedWorld", &DRTTestRunner::evaluateScriptInIsolatedWorld); - bindMethod("evaluateScriptInIsolatedWorldAndReturnValue", &DRTTestRunner::evaluateScriptInIsolatedWorldAndReturnValue); - bindMethod("setIsolatedWorldSecurityOrigin", &DRTTestRunner::setIsolatedWorldSecurityOrigin); - bindMethod("setIsolatedWorldContentSecurityPolicy", &DRTTestRunner::setIsolatedWorldContentSecurityPolicy); - bindMethod("execCommand", &DRTTestRunner::execCommand); - bindMethod("forceRedSelectionColors", &DRTTestRunner::forceRedSelectionColors); #if ENABLE(NOTIFICATIONS) bindMethod("grantWebNotificationPermission", &DRTTestRunner::grantWebNotificationPermission); - bindMethod("denyWebNotificationPermission", &DRTTestRunner::denyWebNotificationPermission); - bindMethod("removeAllWebNotificationPermissions", &DRTTestRunner::removeAllWebNotificationPermissions); - bindMethod("simulateWebNotificationClick", &DRTTestRunner::simulateWebNotificationClick); #endif - bindMethod("findString", &DRTTestRunner::findString); - bindMethod("isCommandEnabled", &DRTTestRunner::isCommandEnabled); - bindMethod("hasCustomPageSizeStyle", &DRTTestRunner::hasCustomPageSizeStyle); - bindMethod("loseCompositorContext", &DRTTestRunner::loseCompositorContext); - bindMethod("markerTextForListItem", &DRTTestRunner::markerTextForListItem); bindMethod("notifyDone", &DRTTestRunner::notifyDone); - bindMethod("numberOfActiveAnimations", &DRTTestRunner::numberOfActiveAnimations); bindMethod("numberOfPendingGeolocationPermissionRequests", &DRTTestRunner:: numberOfPendingGeolocationPermissionRequests); - bindMethod("objCIdentityIsEqual", &DRTTestRunner::objCIdentityIsEqual); bindMethod("overridePreference", &DRTTestRunner::overridePreference); bindMethod("pathToLocalResource", &DRTTestRunner::pathToLocalResource); - bindMethod("pauseAnimationAtTimeOnElementWithId", &DRTTestRunner::pauseAnimationAtTimeOnElementWithId); - bindMethod("pauseTransitionAtTimeOnElementWithId", &DRTTestRunner::pauseTransitionAtTimeOnElementWithId); bindMethod("queueBackNavigation", &DRTTestRunner::queueBackNavigation); bindMethod("queueForwardNavigation", &DRTTestRunner::queueForwardNavigation); bindMethod("queueLoadingScript", &DRTTestRunner::queueLoadingScript); @@ -186,32 +161,24 @@ DRTTestRunner::DRTTestRunner(TestShell* shell) bindMethod("queueLoadHTMLString", &DRTTestRunner::queueLoadHTMLString); bindMethod("queueNonLoadingScript", &DRTTestRunner::queueNonLoadingScript); bindMethod("queueReload", &DRTTestRunner::queueReload); - bindMethod("removeOriginAccessWhitelistEntry", &DRTTestRunner::removeOriginAccessWhitelistEntry); bindMethod("repaintSweepHorizontally", &DRTTestRunner::repaintSweepHorizontally); - bindMethod("resetPageVisibility", &DRTTestRunner::resetPageVisibility); - bindMethod("setAcceptsEditing", &DRTTestRunner::setAcceptsEditing); bindMethod("setAllowDisplayOfInsecureContent", &DRTTestRunner::setAllowDisplayOfInsecureContent); bindMethod("setAllowFileAccessFromFileURLs", &DRTTestRunner::setAllowFileAccessFromFileURLs); bindMethod("setAllowRunningOfInsecureContent", &DRTTestRunner::setAllowRunningOfInsecureContent); bindMethod("setAllowUniversalAccessFromFileURLs", &DRTTestRunner::setAllowUniversalAccessFromFileURLs); bindMethod("setAlwaysAcceptCookies", &DRTTestRunner::setAlwaysAcceptCookies); bindMethod("setAuthorAndUserStylesEnabled", &DRTTestRunner::setAuthorAndUserStylesEnabled); - bindMethod("setAutofilled", &DRTTestRunner::setAutofilled); bindMethod("setCanOpenWindows", &DRTTestRunner::setCanOpenWindows); bindMethod("setCloseRemainingWindowsWhenComplete", &DRTTestRunner::setCloseRemainingWindowsWhenComplete); bindMethod("setCustomPolicyDelegate", &DRTTestRunner::setCustomPolicyDelegate); bindMethod("setDatabaseQuota", &DRTTestRunner::setDatabaseQuota); bindMethod("setDeferMainResourceDataLoad", &DRTTestRunner::setDeferMainResourceDataLoad); - bindMethod("setDomainRelaxationForbiddenForURLScheme", &DRTTestRunner::setDomainRelaxationForbiddenForURLScheme); bindMethod("setAudioData", &DRTTestRunner::setAudioData); bindMethod("setGeolocationPermission", &DRTTestRunner::setGeolocationPermission); - bindMethod("setIconDatabaseEnabled", &DRTTestRunner::setIconDatabaseEnabled); bindMethod("setJavaScriptCanAccessClipboard", &DRTTestRunner::setJavaScriptCanAccessClipboard); - bindMethod("setMinimumTimerInterval", &DRTTestRunner::setMinimumTimerInterval); bindMethod("setMockDeviceOrientation", &DRTTestRunner::setMockDeviceOrientation); bindMethod("setMockGeolocationPositionUnavailableError", &DRTTestRunner::setMockGeolocationPositionUnavailableError); bindMethod("setMockGeolocationPosition", &DRTTestRunner::setMockGeolocationPosition); - bindMethod("setPageVisibility", &DRTTestRunner::setPageVisibility); bindMethod("setPluginsEnabled", &DRTTestRunner::setPluginsEnabled); #if ENABLE(POINTER_LOCK) bindMethod("setPointerLockWillRespondAsynchronously", &DRTTestRunner::setPointerLockWillRespondAsynchronously); @@ -220,81 +187,37 @@ DRTTestRunner::DRTTestRunner(TestShell* shell) bindMethod("setPopupBlockingEnabled", &DRTTestRunner::setPopupBlockingEnabled); bindMethod("setPOSIXLocale", &DRTTestRunner::setPOSIXLocale); bindMethod("setPrinting", &DRTTestRunner::setPrinting); - bindMethod("setScrollbarPolicy", &DRTTestRunner::setScrollbarPolicy); bindMethod("setSelectTrailingWhitespaceEnabled", &DRTTestRunner::setSelectTrailingWhitespaceEnabled); - bindMethod("setTextSubpixelPositioning", &DRTTestRunner::setTextSubpixelPositioning); bindMethod("setBackingScaleFactor", &DRTTestRunner::setBackingScaleFactor); bindMethod("setSmartInsertDeleteEnabled", &DRTTestRunner::setSmartInsertDeleteEnabled); bindMethod("setStopProvisionalFrameLoads", &DRTTestRunner::setStopProvisionalFrameLoads); - bindMethod("setTabKeyCyclesThroughElements", &DRTTestRunner::setTabKeyCyclesThroughElements); bindMethod("setUserStyleSheetEnabled", &DRTTestRunner::setUserStyleSheetEnabled); bindMethod("setUserStyleSheetLocation", &DRTTestRunner::setUserStyleSheetLocation); - bindMethod("setValueForUser", &DRTTestRunner::setValueForUser); bindMethod("setWillSendRequestClearHeader", &DRTTestRunner::setWillSendRequestClearHeader); bindMethod("setWillSendRequestReturnsNull", &DRTTestRunner::setWillSendRequestReturnsNull); bindMethod("setWillSendRequestReturnsNullOnRedirect", &DRTTestRunner::setWillSendRequestReturnsNullOnRedirect); bindMethod("setWindowIsKey", &DRTTestRunner::setWindowIsKey); bindMethod("setXSSAuditorEnabled", &DRTTestRunner::setXSSAuditorEnabled); - bindMethod("setAsynchronousSpellCheckingEnabled", &DRTTestRunner::setAsynchronousSpellCheckingEnabled); bindMethod("showWebInspector", &DRTTestRunner::showWebInspector); #if ENABLE(NOTIFICATIONS) bindMethod("simulateLegacyWebNotificationClick", &DRTTestRunner::simulateLegacyWebNotificationClick); #endif - bindMethod("startSpeechInput", &DRTTestRunner::startSpeechInput); bindMethod("testRepaint", &DRTTestRunner::testRepaint); bindMethod("waitForPolicyDelegate", &DRTTestRunner::waitForPolicyDelegate); bindMethod("waitUntilDone", &DRTTestRunner::waitUntilDone); bindMethod("windowCount", &DRTTestRunner::windowCount); - bindMethod("setTextDirection", &DRTTestRunner::setTextDirection); bindMethod("setImagesAllowed", &DRTTestRunner::setImagesAllowed); bindMethod("setScriptsAllowed", &DRTTestRunner::setScriptsAllowed); bindMethod("setStorageAllowed", &DRTTestRunner::setStorageAllowed); bindMethod("setPluginsAllowed", &DRTTestRunner::setPluginsAllowed); - // The following are stubs. - bindMethod("abortModal", &DRTTestRunner::abortModal); - bindMethod("accessStoredWebScriptObject", &DRTTestRunner::accessStoredWebScriptObject); - bindMethod("addDisallowedURL", &DRTTestRunner::addDisallowedURL); - bindMethod("applicationCacheDiskUsageForOrigin", &DRTTestRunner::applicationCacheDiskUsageForOrigin); - bindMethod("callShouldCloseOnWebView", &DRTTestRunner::callShouldCloseOnWebView); - bindMethod("clearAllApplicationCaches", &DRTTestRunner::clearAllApplicationCaches); - bindMethod("clearApplicationCacheForOrigin", &DRTTestRunner::clearApplicationCacheForOrigin); - bindMethod("clearBackForwardList", &DRTTestRunner::clearBackForwardList); - bindMethod("dumpAsWebArchive", &DRTTestRunner::dumpAsWebArchive); - bindMethod("keepWebHistory", &DRTTestRunner::keepWebHistory); - bindMethod("objCClassNameOf", &DRTTestRunner::objCClassNameOf); - bindMethod("setApplicationCacheOriginQuota", &DRTTestRunner::setApplicationCacheOriginQuota); - bindMethod("setCallCloseOnWebViews", &DRTTestRunner::setCallCloseOnWebViews); - bindMethod("setMainFrameIsFirstResponder", &DRTTestRunner::setMainFrameIsFirstResponder); - bindMethod("setPrivateBrowsingEnabled", &DRTTestRunner::setPrivateBrowsingEnabled); - bindMethod("setUseDashboardCompatibilityMode", &DRTTestRunner::setUseDashboardCompatibilityMode); - bindMethod("storeWebScriptObject", &DRTTestRunner::storeWebScriptObject); - bindMethod("deleteAllLocalStorage", &DRTTestRunner::deleteAllLocalStorage); - bindMethod("localStorageDiskUsageForOrigin", &DRTTestRunner::localStorageDiskUsageForOrigin); - bindMethod("originsWithLocalStorage", &DRTTestRunner::originsWithLocalStorage); - bindMethod("deleteLocalStorageForOrigin", &DRTTestRunner::deleteLocalStorageForOrigin); - bindMethod("observeStorageTrackerNotifications", &DRTTestRunner::observeStorageTrackerNotifications); - bindMethod("syncLocalStorage", &DRTTestRunner::syncLocalStorage); bindMethod("setShouldStayOnPageAfterHandlingBeforeUnload", &DRTTestRunner::setShouldStayOnPageAfterHandlingBeforeUnload); - bindMethod("enableFixedLayoutMode", &DRTTestRunner::enableFixedLayoutMode); - bindMethod("setFixedLayoutSize", &DRTTestRunner::setFixedLayoutSize); - bindMethod("selectionAsMarkup", &DRTTestRunner::selectionAsMarkup); - bindMethod("setHasCustomFullScreenBehavior", &DRTTestRunner::setHasCustomFullScreenBehavior); - bindMethod("textSurroundingNode", &DRTTestRunner::textSurroundingNode); - - // The fallback method is called when an unknown method is invoked. - bindFallbackMethod(&DRTTestRunner::fallbackMethod); // Shared properties. - // globalFlag is used by a number of layout tests in - // LayoutTests\http\tests\security\dataURL. - bindProperty("globalFlag", &m_globalFlag); // webHistoryItemCount is used by tests in LayoutTests\http\tests\history bindProperty("webHistoryItemCount", &m_webHistoryItemCount); bindProperty("titleTextDirection", &m_titleTextDirection); - bindProperty("platformName", &m_platformName); bindProperty("interceptPostMessage", &m_interceptPostMessage); - bindProperty("workerThreadCount", &DRTTestRunner::workerThreadCount); bindMethod("sendWebIntentResponse", &DRTTestRunner::sendWebIntentResponse); bindMethod("deliverWebIntent", &DRTTestRunner::deliverWebIntent); } @@ -363,12 +286,6 @@ void DRTTestRunner::dumpAsText(const CppArgumentList& arguments, CppVariant* res result->setNull(); } -void DRTTestRunner::dumpDatabaseCallbacks(const CppArgumentList&, CppVariant* result) -{ - // Do nothing; we don't use this flag anywhere for now - result->setNull(); -} - void DRTTestRunner::dumpEditingCallbacks(const CppArgumentList&, CppVariant* result) { m_dumpEditingCallbacks = true; @@ -447,13 +364,6 @@ void DRTTestRunner::dumpCreateView(const CppArgumentList&, CppVariant* result) result->setNull(); } -void DRTTestRunner::setAcceptsEditing(const CppArgumentList& arguments, CppVariant* result) -{ - if (arguments.size() > 0 && arguments[0].isBool()) - m_acceptsEditing = arguments[0].value.boolValue; - result->setNull(); -} - void DRTTestRunner::waitUntilDone(const CppArgumentList&, CppVariant* result) { if (!webkit_support::BeingDebugged()) @@ -633,31 +543,11 @@ void DRTTestRunner::queueLoadHTMLString(const CppArgumentList& arguments, CppVar result->setNull(); } -void DRTTestRunner::objCIdentityIsEqual(const CppArgumentList& arguments, CppVariant* result) -{ - if (arguments.size() < 2) { - // This is the best we can do to return an error. - result->setNull(); - return; - } - result->set(arguments[0].isEqual(arguments[1])); -} - void DRTTestRunner::reset() { - if (m_shell) { - m_shell->webView()->setZoomLevel(false, 0); - m_shell->webView()->setTabKeyCyclesThroughElements(true); -#if !OS(DARWIN) && !OS(WINDOWS) // Actually, TOOLKIT_GTK - // (Constants copied because we can't depend on the header that defined - // them from this file.) - m_shell->webView()->setSelectionColors(0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232); -#endif - m_shell->webView()->removeAllUserContent(); - WebKit::WebSize empty; - m_shell->webView()->disableAutoResizeMode(); + TestRunner::reset(); + if (m_shell) m_shell->webViewHost()->setDeviceScaleFactor(1); - } m_dumpAsText = false; m_dumpAsAudio = false; m_dumpCreateView = false; @@ -675,24 +565,19 @@ void DRTTestRunner::reset() m_dumpTitleChanges = false; m_dumpPermissionClientCallbacks = false; m_generatePixelResults = true; - m_acceptsEditing = true; m_waitUntilDone = false; m_canOpenWindows = false; m_testRepaint = false; m_sweepHorizontally = false; - m_shouldAddFileToPasteboard = false; m_stopProvisionalFrameLoads = false; m_deferMainResourceDataLoad = true; - m_globalFlag.set(false); m_webHistoryItemCount.set(0); m_titleTextDirection.set("ltr"); - m_platformName.set("chromium"); m_interceptPostMessage.set(false); m_userStyleSheetLocation = WebURL(); m_isPrinting = false; webkit_support::SetAcceptAllCookies(false); - WebSecurityPolicy::resetOriginAccessWhitelists(); // Reset the default quota for each origin to 5MB webkit_support::SetDatabaseQuota(5 * 1024 * 1024); @@ -706,10 +591,6 @@ void DRTTestRunner::reset() m_workQueue.reset(); m_taskList.revokeAll(); m_shouldStayOnPageAfterHandlingBeforeUnload = false; - m_hasCustomFullScreenBehavior = false; -#if OS(LINUX) || OS(ANDROID) - WebFontRendering::setSubpixelPositioning(false); -#endif } void DRTTestRunner::locationChangeDone() @@ -736,13 +617,6 @@ void DRTTestRunner::setCanOpenWindows(const CppArgumentList&, CppVariant* result result->setNull(); } -void DRTTestRunner::setTabKeyCyclesThroughElements(const CppArgumentList& arguments, CppVariant* result) -{ - if (arguments.size() > 0 && arguments[0].isBool()) - m_shell->webView()->setTabKeyCyclesThroughElements(arguments[0].toBoolean()); - result->setNull(); -} - void DRTTestRunner::windowCount(const CppArgumentList&, CppVariant* result) { result->set(static_cast<int>(m_shell->windowCount())); @@ -762,13 +636,6 @@ void DRTTestRunner::setAlwaysAcceptCookies(const CppArgumentList& arguments, Cpp result->setNull(); } -void DRTTestRunner::setAsynchronousSpellCheckingEnabled(const CppArgumentList& arguments, CppVariant* result) -{ - if (arguments.size() > 0 && arguments[0].isBool()) - m_shell->webView()->settings()->setAsynchronousSpellCheckingEnabled(cppVariantToBool(arguments[0])); - result->setNull(); -} - void DRTTestRunner::showWebInspector(const CppArgumentList&, CppVariant* result) { m_shell->showDevTools(); @@ -817,35 +684,6 @@ void DRTTestRunner::setAuthorAndUserStylesEnabled(const CppArgumentList& argumen result->setNull(); } -void DRTTestRunner::execCommand(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() <= 0 || !arguments[0].isString()) - return; - - std::string command = arguments[0].toString(); - std::string value(""); - // Ignore the second parameter (which is userInterface) - // since this command emulates a manual action. - if (arguments.size() >= 3 && arguments[2].isString()) - value = arguments[2].toString(); - - // Note: webkit's version does not return the boolean, so neither do we. - m_shell->webView()->focusedFrame()->executeCommand(WebString::fromUTF8(command), WebString::fromUTF8(value)); -} - -void DRTTestRunner::isCommandEnabled(const CppArgumentList& arguments, CppVariant* result) -{ - if (arguments.size() <= 0 || !arguments[0].isString()) { - result->setNull(); - return; - } - - std::string command = arguments[0].toString(); - bool rv = m_shell->webView()->focusedFrame()->isCommandEnabled(WebString::fromUTF8(command)); - result->set(rv); -} - void DRTTestRunner::setPopupBlockingEnabled(const CppArgumentList& arguments, CppVariant* result) { if (arguments.size() > 0 && arguments[0].isBool()) { @@ -884,49 +722,6 @@ void DRTTestRunner::setPluginsAllowed(const CppArgumentList& arguments, CppVaria result->setNull(); } -void DRTTestRunner::setUseDashboardCompatibilityMode(const CppArgumentList&, CppVariant* result) -{ - // We have no need to support Dashboard Compatibility Mode (mac-only) - result->setNull(); -} - -void DRTTestRunner::clearAllApplicationCaches(const CppArgumentList&, CppVariant* result) -{ - // FIXME: Implement to support application cache quotas. - result->setNull(); -} - -void DRTTestRunner::clearApplicationCacheForOrigin(const CppArgumentList&, CppVariant* result) -{ - // FIXME: Implement to support deleting all application cache for an origin. - result->setNull(); -} - -void DRTTestRunner::setApplicationCacheOriginQuota(const CppArgumentList&, CppVariant* result) -{ - // FIXME: Implement to support application cache quotas. - result->setNull(); -} - -void DRTTestRunner::originsWithApplicationCache(const CppArgumentList&, CppVariant* result) -{ - // FIXME: Implement to support getting origins that have application caches. - result->setNull(); -} - -void DRTTestRunner::applicationCacheDiskUsageForOrigin(const CppArgumentList&, CppVariant* result) -{ - // FIXME: Implement to support getting disk usage by all application cache for an origin. - result->setNull(); -} - -void DRTTestRunner::setScrollbarPolicy(const CppArgumentList&, CppVariant* result) -{ - // FIXME: implement. - // Currently only has a non-null implementation on QT. - result->setNull(); -} - void DRTTestRunner::setCustomPolicyDelegate(const CppArgumentList& arguments, CppVariant* result) { if (arguments.size() > 0 && arguments[0].isBool()) { @@ -1008,12 +803,6 @@ void DRTTestRunner::pathToLocalResource(const CppArgumentList& arguments, CppVar result->set(webkit_support::RewriteLayoutTestsURL(url).spec()); } -void DRTTestRunner::addFileToPasteboardOnDrag(const CppArgumentList&, CppVariant* result) -{ - result->setNull(); - m_shouldAddFileToPasteboard = true; -} - void DRTTestRunner::setStopProvisionalFrameLoads(const CppArgumentList&, CppVariant* result) { result->setNull(); @@ -1034,97 +823,6 @@ void DRTTestRunner::setSelectTrailingWhitespaceEnabled(const CppArgumentList& ar result->setNull(); } -bool DRTTestRunner::pauseAnimationAtTimeOnElementWithId(const WebString& animationName, double time, const WebString& elementId) -{ - WebFrame* webFrame = m_shell->webView()->mainFrame(); - if (!webFrame) - return false; - - WebAnimationController* controller = webFrame->animationController(); - if (!controller) - return false; - - WebElement element = webFrame->document().getElementById(elementId); - if (element.isNull()) - return false; - return controller->pauseAnimationAtTime(element, animationName, time); -} - -bool DRTTestRunner::pauseTransitionAtTimeOnElementWithId(const WebString& propertyName, double time, const WebString& elementId) -{ - WebFrame* webFrame = m_shell->webView()->mainFrame(); - if (!webFrame) - return false; - - WebAnimationController* controller = webFrame->animationController(); - if (!controller) - return false; - - WebElement element = webFrame->document().getElementById(elementId); - if (element.isNull()) - return false; - return controller->pauseTransitionAtTime(element, propertyName, time); -} - -bool DRTTestRunner::elementDoesAutoCompleteForElementWithId(const WebString& elementId) -{ - WebFrame* webFrame = m_shell->webView()->mainFrame(); - if (!webFrame) - return false; - - WebElement element = webFrame->document().getElementById(elementId); - if (element.isNull() || !element.hasTagName("input")) - return false; - - WebInputElement inputElement = element.to<WebInputElement>(); - return inputElement.autoComplete(); -} - -int DRTTestRunner::numberOfActiveAnimations() -{ - WebFrame* webFrame = m_shell->webView()->mainFrame(); - if (!webFrame) - return -1; - - WebAnimationController* controller = webFrame->animationController(); - if (!controller) - return -1; - - return controller->numberOfActiveAnimations(); -} - -void DRTTestRunner::pauseAnimationAtTimeOnElementWithId(const CppArgumentList& arguments, CppVariant* result) -{ - result->set(false); - if (arguments.size() > 2 && arguments[0].isString() && arguments[1].isNumber() && arguments[2].isString()) { - WebString animationName = cppVariantToWebString(arguments[0]); - double time = arguments[1].toDouble(); - WebString elementId = cppVariantToWebString(arguments[2]); - result->set(pauseAnimationAtTimeOnElementWithId(animationName, time, elementId)); - } -} - -void DRTTestRunner::pauseTransitionAtTimeOnElementWithId(const CppArgumentList& arguments, CppVariant* result) -{ - result->set(false); - if (arguments.size() > 2 && arguments[0].isString() && arguments[1].isNumber() && arguments[2].isString()) { - WebString propertyName = cppVariantToWebString(arguments[0]); - double time = arguments[1].toDouble(); - WebString elementId = cppVariantToWebString(arguments[2]); - result->set(pauseTransitionAtTimeOnElementWithId(propertyName, time, elementId)); - } -} - -void DRTTestRunner::elementDoesAutoCompleteForElementWithId(const CppArgumentList& arguments, CppVariant* result) -{ - if (arguments.size() != 1 || !arguments[0].isString()) { - result->set(false); - return; - } - WebString elementId = cppVariantToWebString(arguments[0]); - result->set(elementDoesAutoCompleteForElementWithId(elementId)); -} - void DRTTestRunner::enableAutoResizeMode(const CppArgumentList& arguments, CppVariant* result) { if (arguments.size() != 4) { @@ -1159,29 +857,6 @@ void DRTTestRunner::disableAutoResizeMode(const CppArgumentList& arguments, CppV result->set(true); } -void DRTTestRunner::numberOfActiveAnimations(const CppArgumentList&, CppVariant* result) -{ - result->set(numberOfActiveAnimations()); -} - -void DRTTestRunner::disableImageLoading(const CppArgumentList&, CppVariant* result) -{ - m_shell->preferences()->loadsImagesAutomatically = false; - m_shell->applyPreferences(); - result->setNull(); -} - -void DRTTestRunner::setIconDatabaseEnabled(const CppArgumentList&, CppVariant* result) -{ - // We don't use the WebKit icon database. - result->setNull(); -} - -void DRTTestRunner::callShouldCloseOnWebView(const CppArgumentList&, CppVariant* result) -{ - result->set(m_shell->webView()->dispatchBeforeUnloadEvent()); -} - #if ENABLE(NOTIFICATIONS) void DRTTestRunner::grantWebNotificationPermission(const CppArgumentList& arguments, CppVariant* result) { @@ -1195,24 +870,6 @@ void DRTTestRunner::grantWebNotificationPermission(const CppArgumentList& argume result->set(true); } -void DRTTestRunner::denyWebNotificationPermission(const CppArgumentList& arguments, CppVariant* result) -{ - // FIXME: Implement. - result->setNull(); -} - -void DRTTestRunner::removeAllWebNotificationPermissions(const CppArgumentList& arguments, CppVariant* result) -{ - // FIXME: Implement. - result->setNull(); -} - -void DRTTestRunner::simulateWebNotificationClick(const CppArgumentList& arguments, CppVariant* result) -{ - // FIXME: Implement. - result->setNull(); -} - void DRTTestRunner::simulateLegacyWebNotificationClick(const CppArgumentList& arguments, CppVariant* result) { if (arguments.size() != 1 || !arguments[0].isString()) { @@ -1228,33 +885,12 @@ void DRTTestRunner::simulateLegacyWebNotificationClick(const CppArgumentList& ar } #endif -void DRTTestRunner::setDomainRelaxationForbiddenForURLScheme(const CppArgumentList& arguments, CppVariant* result) -{ - if (arguments.size() != 2 || !arguments[0].isBool() || !arguments[1].isString()) - return; - m_shell->webView()->setDomainRelaxationForbidden(cppVariantToBool(arguments[0]), cppVariantToWebString(arguments[1])); -} - void DRTTestRunner::setDeferMainResourceDataLoad(const CppArgumentList& arguments, CppVariant* result) { if (arguments.size() == 1) m_deferMainResourceDataLoad = cppVariantToBool(arguments[0]); } -// -// Unimplemented stubs -// - -void DRTTestRunner::dumpAsWebArchive(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - -void DRTTestRunner::setMainFrameIsFirstResponder(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - void DRTTestRunner::dumpSelectionRect(const CppArgumentList& arguments, CppVariant* result) { m_dumpSelectionRect = true; @@ -1266,7 +902,7 @@ void DRTTestRunner::display(const CppArgumentList& arguments, CppVariant* result WebViewHost* host = m_shell->webViewHost(); const WebKit::WebSize& size = m_shell->webView()->size(); WebRect rect(0, 0, size.width, size.height); - host->updatePaintRect(rect); + host->proxy()->setPaintRect(rect); host->paintInvalidatedRegion(); host->displayRepaintMask(); result->setNull(); @@ -1292,46 +928,6 @@ void DRTTestRunner::repaintSweepHorizontally(const CppArgumentList&, CppVariant* result->setNull(); } -void DRTTestRunner::clearBackForwardList(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - -void DRTTestRunner::keepWebHistory(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - -void DRTTestRunner::storeWebScriptObject(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - -void DRTTestRunner::accessStoredWebScriptObject(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - -void DRTTestRunner::objCClassNameOf(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - -void DRTTestRunner::addDisallowedURL(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - -void DRTTestRunner::setCallCloseOnWebViews(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - -void DRTTestRunner::setPrivateBrowsingEnabled(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - void DRTTestRunner::setJavaScriptCanAccessClipboard(const CppArgumentList& arguments, CppVariant* result) { if (arguments.size() > 0 && arguments[0].isBool()) { @@ -1350,70 +946,6 @@ void DRTTestRunner::setXSSAuditorEnabled(const CppArgumentList& arguments, CppVa result->setNull(); } -void DRTTestRunner::evaluateScriptInIsolatedWorldAndReturnValue(const CppArgumentList& arguments, CppVariant* result) -{ - v8::HandleScope scope; - WebVector<v8::Local<v8::Value> > values; - if (arguments.size() >= 2 && arguments[0].isNumber() && arguments[1].isString()) { - WebScriptSource source(cppVariantToWebString(arguments[1])); - // This relies on the iframe focusing itself when it loads. This is a bit - // sketchy, but it seems to be what other tests do. - m_shell->webView()->focusedFrame()->executeScriptInIsolatedWorld(arguments[0].toInt32(), &source, 1, 1, &values); - } - result->setNull(); - // Since only one script was added, only one result is expected - if (values.size() == 1 && !values[0].IsEmpty()) { - v8::Local<v8::Value> scriptValue = values[0]; - // FIXME: There are many more types that can be handled. - if (scriptValue->IsString()) { - v8::String::AsciiValue asciiV8(scriptValue); - result->set(std::string(*asciiV8)); - } else if (scriptValue->IsBoolean()) - result->set(scriptValue->ToBoolean()->Value()); - else if (scriptValue->IsNumber()) { - if (scriptValue->IsInt32()) - result->set(scriptValue->ToInt32()->Value()); - else - result->set(scriptValue->ToNumber()->Value()); - } else if (scriptValue->IsNull()) - result->setNull(); - } -} - -void DRTTestRunner::evaluateScriptInIsolatedWorld(const CppArgumentList& arguments, CppVariant* result) -{ - if (arguments.size() >= 2 && arguments[0].isNumber() && arguments[1].isString()) { - WebScriptSource source(cppVariantToWebString(arguments[1])); - // This relies on the iframe focusing itself when it loads. This is a bit - // sketchy, but it seems to be what other tests do. - m_shell->webView()->focusedFrame()->executeScriptInIsolatedWorld(arguments[0].toInt32(), &source, 1, 1); - } - result->setNull(); -} - -void DRTTestRunner::setIsolatedWorldSecurityOrigin(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - - if (arguments.size() != 2 || !arguments[0].isNumber() || !(arguments[1].isString() || arguments[1].isNull())) - return; - - WebSecurityOrigin origin; - if (arguments[1].isString()) - origin = WebSecurityOrigin::createFromString(cppVariantToWebString(arguments[1])); - m_shell->webView()->focusedFrame()->setIsolatedWorldSecurityOrigin(arguments[0].toInt32(), origin); -} - -void DRTTestRunner::setIsolatedWorldContentSecurityPolicy(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - - if (arguments.size() != 2 || !arguments[0].isNumber() || !arguments[1].isString()) - return; - - m_shell->webView()->focusedFrame()->setIsolatedWorldContentSecurityPolicy(arguments[0].toInt32(), cppVariantToWebString(arguments[1])); -} - void DRTTestRunner::setAllowUniversalAccessFromFileURLs(const CppArgumentList& arguments, CppVariant* result) { if (arguments.size() > 0 && arguments[0].isBool()) { @@ -1448,63 +980,6 @@ void DRTTestRunner::setAllowRunningOfInsecureContent(const CppArgumentList& argu result->setNull(); } -// Need these conversions because the format of the value for booleans -// may vary - for example, on mac "1" and "0" are used for boolean. -bool DRTTestRunner::cppVariantToBool(const CppVariant& value) -{ - if (value.isBool()) - return value.toBoolean(); - if (value.isNumber()) - return value.toInt32(); - if (value.isString()) { - string valueString = value.toString(); - if (valueString == "true" || valueString == "1") - return true; - if (valueString == "false" || valueString == "0") - return false; - } - logErrorToConsole("Invalid value. Expected boolean value."); - return false; -} - -int32_t DRTTestRunner::cppVariantToInt32(const CppVariant& value) -{ - if (value.isNumber()) - return value.toInt32(); - if (value.isString()) { - string stringSource = value.toString(); - const char* source = stringSource.data(); - char* end; - long number = strtol(source, &end, 10); - if (end == source + stringSource.length() && number >= numeric_limits<int32_t>::min() && number <= numeric_limits<int32_t>::max()) - return static_cast<int32_t>(number); - } - logErrorToConsole("Invalid value for preference. Expected integer value."); - return 0; -} - -WebString DRTTestRunner::cppVariantToWebString(const CppVariant& value) -{ - if (!value.isString()) { - logErrorToConsole("Invalid value for preference. Expected string value."); - return WebString(); - } - return WebString::fromUTF8(value.toString()); -} - -Vector<WebString> DRTTestRunner::cppVariantToWebStringArray(const CppVariant& value) -{ - if (!value.isObject()) { - logErrorToConsole("Invalid value for preference. Expected object value."); - return Vector<WebString>(); - } - Vector<WebString> resultVector; - Vector<string> stringVector = value.toStringVector(); - for (size_t i = 0; i < stringVector.size(); ++i) - resultVector.append(WebString::fromUTF8(stringVector[i].c_str())); - return resultVector; -} - // Sets map based on scriptFontPairs, a collapsed vector of pairs of ISO 15924 // four-letter script code and font such as: // { "Arab", "My Arabic Font", "Grek", "My Greek Font" } @@ -1624,55 +1099,11 @@ void DRTTestRunner::overridePreference(const CppArgumentList& arguments, CppVari } else { string message("Invalid name for preference: "); message.append(key); - logErrorToConsole(message); + printErrorMessage(message); } m_shell->applyPreferences(); } -void DRTTestRunner::fallbackMethod(const CppArgumentList&, CppVariant* result) -{ - printf("CONSOLE MESSAGE: JavaScript ERROR: unknown method called on DRTTestRunner\n"); - result->setNull(); -} - -void DRTTestRunner::addOriginAccessWhitelistEntry(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - - if (arguments.size() != 4 || !arguments[0].isString() || !arguments[1].isString() - || !arguments[2].isString() || !arguments[3].isBool()) - return; - - WebKit::WebURL url(GURL(arguments[0].toString())); - if (!url.isValid()) - return; - - WebSecurityPolicy::addOriginAccessWhitelistEntry( - url, - cppVariantToWebString(arguments[1]), - cppVariantToWebString(arguments[2]), - arguments[3].toBoolean()); -} - -void DRTTestRunner::removeOriginAccessWhitelistEntry(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - - if (arguments.size() != 4 || !arguments[0].isString() || !arguments[1].isString() - || !arguments[2].isString() || !arguments[3].isBool()) - return; - - WebKit::WebURL url(GURL(arguments[0].toString())); - if (!url.isValid()) - return; - - WebSecurityPolicy::removeOriginAccessWhitelistEntry( - url, - cppVariantToWebString(arguments[1]), - cppVariantToWebString(arguments[2]), - arguments[3].toBoolean()); -} - void DRTTestRunner::clearAllDatabases(const CppArgumentList& arguments, CppVariant* result) { result->setNull(); @@ -1693,49 +1124,12 @@ void DRTTestRunner::setPOSIXLocale(const CppArgumentList& arguments, CppVariant* setlocale(LC_ALL, arguments[0].toString().c_str()); } -// Parse a single argument. The method returns true if there is an argument that -// is a number or if there is no argument at all. It returns false only if there -// is some argument that is not a number. The value parameter is filled with the -// parsed number, or given the default if there is no argument. -static bool parseCppArgumentInt32(const CppArgumentList& arguments, int argIndex, int* value, int defaultValue) -{ - if (static_cast<int>(arguments.size()) > argIndex) { - if (!arguments[argIndex].isNumber()) - return false; - *value = arguments[argIndex].toInt32(); - return true; - } - *value = defaultValue; - return true; -} - -static bool parsePageNumber(const CppArgumentList& arguments, int argOffset, int* pageNumber) -{ - if (static_cast<int>(arguments.size()) > argOffset + 1) - return false; - if (!parseCppArgumentInt32(arguments, argOffset, pageNumber, 0)) - return false; - return true; -} - void DRTTestRunner::setPrinting(const CppArgumentList& arguments, CppVariant* result) { setIsPrinting(true); result->setNull(); } -void DRTTestRunner::hasCustomPageSizeStyle(const CppArgumentList& arguments, CppVariant* result) -{ - result->set(false); - int pageIndex = 0; - if (!parsePageNumber(arguments, 0, &pageIndex)) - return; - WebFrame* frame = m_shell->webView()->mainFrame(); - if (!frame) - return; - result->set(frame->hasCustomPageSizeStyle(pageIndex)); -} - void DRTTestRunner::numberOfPendingGeolocationPermissionRequests(const CppArgumentList& arguments, CppVariant* result) { result->setNull(); @@ -1746,13 +1140,6 @@ void DRTTestRunner::numberOfPendingGeolocationPermissionRequests(const CppArgume result->set(numberOfRequests); } -void DRTTestRunner::logErrorToConsole(const std::string& text) -{ - m_shell->webViewHost()->didAddMessageToConsole( - WebConsoleMessage(WebConsoleMessage::LevelError, WebString::fromUTF8(text)), - WebString(), 0); -} - void DRTTestRunner::evaluateInWebInspector(const CppArgumentList& arguments, CppVariant* result) { result->setNull(); @@ -1761,36 +1148,6 @@ void DRTTestRunner::evaluateInWebInspector(const CppArgumentList& arguments, Cpp m_shell->drtDevToolsAgent()->evaluateInWebInspector(arguments[0].toInt32(), arguments[1].toString()); } -void DRTTestRunner::forceRedSelectionColors(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - m_shell->webView()->setSelectionColors(0xffee0000, 0xff00ee00, 0xff000000, 0xffc0c0c0); -} - -void DRTTestRunner::addUserScript(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() < 3 || !arguments[0].isString() || !arguments[1].isBool() || !arguments[2].isBool()) - return; - WebView::addUserScript( - cppVariantToWebString(arguments[0]), WebVector<WebString>(), - arguments[1].toBoolean() ? WebView::UserScriptInjectAtDocumentStart : WebView::UserScriptInjectAtDocumentEnd, - arguments[2].toBoolean() ? WebView::UserContentInjectInAllFrames : WebView::UserContentInjectInTopFrameOnly); -} - -void DRTTestRunner::addUserStyleSheet(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() < 2 || !arguments[0].isString() || !arguments[1].isBool()) - return; - WebView::addUserStyleSheet( - cppVariantToWebString(arguments[0]), WebVector<WebString>(), - arguments[1].toBoolean() ? WebView::UserContentInjectInAllFrames : WebView::UserContentInjectInTopFrameOnly, - // Chromium defaults to InjectInSubsequentDocuments, but for compatibility - // with the other ports' DRTs, we use UserStyleInjectInExistingDocuments. - WebView::UserStyleInjectInExistingDocuments); -} - void DRTTestRunner::setMockDeviceOrientation(const CppArgumentList& arguments, CppVariant* result) { result->setNull(); @@ -1845,11 +1202,6 @@ void DRTTestRunner::setMockGeolocationPositionUnavailableError(const CppArgument windowList[i]->geolocationClientMock()->setPositionUnavailableError(cppVariantToWebString(arguments[0])); } -void DRTTestRunner::abortModal(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); -} - #if ENABLE(INPUT_SPEECH) void DRTTestRunner::addMockSpeechInputResult(const CppArgumentList& arguments, CppVariant* result) { @@ -1901,145 +1253,6 @@ void DRTTestRunner::wasMockSpeechRecognitionAborted(const CppArgumentList&, CppV } #endif -void DRTTestRunner::startSpeechInput(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() != 1) - return; - - WebElement element; - if (!WebBindings::getElement(arguments[0].value.objectValue, &element)) - return; - - WebInputElement* input = toWebInputElement(&element); - if (!input) - return; - - if (!input->isSpeechInputEnabled()) - return; - - input->startSpeechInput(); -} - -void DRTTestRunner::loseCompositorContext(const CppArgumentList& args, CppVariant*) -{ - int numTimes; - if (args.size() == 1 || !args[0].isNumber()) - numTimes = 1; - else - numTimes = args[0].toInt32(); - m_shell->webView()->loseCompositorContext(numTimes); -} - -void DRTTestRunner::markerTextForListItem(const CppArgumentList& args, CppVariant* result) -{ - WebElement element; - if (!WebBindings::getElement(args[0].value.objectValue, &element)) - result->setNull(); - else - result->set(element.document().frame()->markerTextForListItem(element).utf8()); -} - -void DRTTestRunner::findString(const CppArgumentList& arguments, CppVariant* result) -{ - if (arguments.size() < 1 || !arguments[0].isString()) - return; - - WebFindOptions findOptions; - bool wrapAround = false; - if (arguments.size() >= 2) { - Vector<std::string> optionsArray = arguments[1].toStringVector(); - findOptions.matchCase = true; - - for (size_t i = 0; i < optionsArray.size(); ++i) { - const std::string& option = optionsArray[i]; - // FIXME: Support all the options, so we can run findString.html too. - if (option == "CaseInsensitive") - findOptions.matchCase = false; - else if (option == "Backwards") - findOptions.forward = false; - else if (option == "WrapAround") - wrapAround = true; - } - } - - WebFrame* frame = m_shell->webView()->mainFrame(); - const bool findResult = frame->find(0, cppVariantToWebString(arguments[0]), findOptions, wrapAround, 0); - result->set(findResult); -} - -void DRTTestRunner::setMinimumTimerInterval(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() < 1 || !arguments[0].isNumber()) - return; - m_shell->webView()->settings()->setMinimumTimerInterval(arguments[0].toDouble()); -} - -void DRTTestRunner::setAutofilled(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() != 2 || !arguments[1].isBool()) - return; - - WebElement element; - if (!WebBindings::getElement(arguments[0].value.objectValue, &element)) - return; - - WebInputElement* input = toWebInputElement(&element); - if (!input) - return; - - input->setAutofilled(arguments[1].value.boolValue); -} - -void DRTTestRunner::setValueForUser(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() != 2) - return; - - WebElement element; - if (!WebBindings::getElement(arguments[0].value.objectValue, &element)) - return; - - WebInputElement* input = toWebInputElement(&element); - if (!input) - return; - - input->setValue(cppVariantToWebString(arguments[1]), true); -} - -void DRTTestRunner::deleteAllLocalStorage(const CppArgumentList& arguments, CppVariant*) -{ - // Not Implemented -} - -void DRTTestRunner::localStorageDiskUsageForOrigin(const CppArgumentList& arguments, CppVariant*) -{ - // Not Implemented -} - -void DRTTestRunner::originsWithLocalStorage(const CppArgumentList& arguments, CppVariant*) -{ - // Not Implemented -} - -void DRTTestRunner::deleteLocalStorageForOrigin(const CppArgumentList& arguments, CppVariant*) -{ - // Not Implemented -} - -void DRTTestRunner::observeStorageTrackerNotifications(const CppArgumentList&, CppVariant*) -{ - // Not Implemented -} - -void DRTTestRunner::syncLocalStorage(const CppArgumentList&, CppVariant*) -{ - // Not Implemented -} - void DRTTestRunner::setShouldStayOnPageAfterHandlingBeforeUnload(const CppArgumentList& arguments, CppVariant* result) { if (arguments.size() == 1 && arguments[0].isBool()) @@ -2048,35 +1261,6 @@ void DRTTestRunner::setShouldStayOnPageAfterHandlingBeforeUnload(const CppArgume result->setNull(); } -void DRTTestRunner::enableFixedLayoutMode(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() < 1 || !arguments[0].isBool()) - return; - bool enableFixedLayout = arguments[0].toBoolean(); - m_shell->webView()->enableFixedLayoutMode(enableFixedLayout); -} - -void DRTTestRunner::setFixedLayoutSize(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() < 2 || !arguments[0].isNumber() || !arguments[1].isNumber()) - return; - int width = arguments[0].toInt32(); - int height = arguments[1].toInt32(); - m_shell->webView()->setFixedLayoutSize(WebSize(width, height)); -} - -void DRTTestRunner::selectionAsMarkup(const CppArgumentList& arguments, CppVariant* result) -{ - result->set(m_shell->webView()->mainFrame()->selectionAsMarkup().utf8()); -} - -void DRTTestRunner::workerThreadCount(CppVariant* result) -{ - result->set(static_cast<int>(WebWorkerInfo::dedicatedWorkerCount())); -} - void DRTTestRunner::sendWebIntentResponse(const CppArgumentList& arguments, CppVariant* result) { v8::HandleScope scope; @@ -2120,17 +1304,6 @@ void DRTTestRunner::deliverWebIntent(const CppArgumentList& arguments, CppVarian m_shell->webView()->mainFrame()->deliverIntent(intent, 0, m_intentClient.get()); } -void DRTTestRunner::setTextSubpixelPositioning(const CppArgumentList& arguments, CppVariant* result) -{ -#if OS(LINUX) || OS(ANDROID) - // Since FontConfig doesn't provide a variable to control subpixel positioning, we'll fall back - // to setting it globally for all fonts. - if (arguments.size() > 0 && arguments[0].isBool()) - WebFontRendering::setSubpixelPositioning(arguments[0].value.boolValue); -#endif - result->setNull(); -} - class InvokeCallbackTask : public WebMethodTask<DRTTestRunner> { public: InvokeCallbackTask(DRTTestRunner* object, PassOwnArrayPtr<CppVariant> callbackArguments, uint32_t numberOfArguments) @@ -2174,52 +1347,6 @@ void DRTTestRunner::setPluginsEnabled(const CppArgumentList& arguments, CppVaria result->setNull(); } -void DRTTestRunner::resetPageVisibility(const CppArgumentList& arguments, CppVariant* result) -{ - m_shell->webView()->setVisibilityState(WebPageVisibilityStateVisible, true); -} - -void DRTTestRunner::setPageVisibility(const CppArgumentList& arguments, CppVariant* result) -{ - if (arguments.size() > 0 && arguments[0].isString()) { - string newVisibility = arguments[0].toString(); - if (newVisibility == "visible") - m_shell->webView()->setVisibilityState(WebPageVisibilityStateVisible, false); - else if (newVisibility == "hidden") - m_shell->webView()->setVisibilityState(WebPageVisibilityStateHidden, false); - else if (newVisibility == "prerender") - m_shell->webView()->setVisibilityState(WebPageVisibilityStatePrerender, false); - else if (newVisibility == "preview") - m_shell->webView()->setVisibilityState(WebPageVisibilityStatePreview, false); - } -} - -void DRTTestRunner::setAutomaticLinkDetectionEnabled(bool) -{ - // Not Implemented -} - -void DRTTestRunner::setTextDirection(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() != 1 || !arguments[0].isString()) - return; - - // Map a direction name to a WebTextDirection value. - std::string directionName = arguments[0].toString(); - WebKit::WebTextDirection direction; - if (directionName == "auto") - direction = WebKit::WebTextDirectionDefault; - else if (directionName == "rtl") - direction = WebKit::WebTextDirectionRightToLeft; - else if (directionName == "ltr") - direction = WebKit::WebTextDirectionLeftToRight; - else - return; - - m_shell->webView()->setTextDirection(direction); -} - void DRTTestRunner::setAudioData(const CppArgumentList& arguments, CppVariant* result) { result->setNull(); @@ -2237,14 +1364,6 @@ void DRTTestRunner::setAudioData(const CppArgumentList& arguments, CppVariant* r setShouldDumpAsAudio(true); } -void DRTTestRunner::setHasCustomFullScreenBehavior(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() < 1 || !arguments[0].isBool()) - return; - m_hasCustomFullScreenBehavior = arguments[0].toBoolean(); -} - #if ENABLE(POINTER_LOCK) void DRTTestRunner::didAcquirePointerLock(const CppArgumentList&, CppVariant* result) { @@ -2276,27 +1395,3 @@ void DRTTestRunner::setPointerLockWillFailSynchronously(const CppArgumentList&, result->setNull(); } #endif - -void DRTTestRunner::textSurroundingNode(const CppArgumentList& arguments, CppVariant* result) -{ - result->setNull(); - if (arguments.size() < 4 || !arguments[0].isObject() || !arguments[1].isNumber() || !arguments[2].isNumber() || !arguments[3].isNumber()) - return; - - WebNode node; - if (!WebBindings::getNode(arguments[0].value.objectValue, &node)) - return; - - if (node.isNull() || !node.isTextNode()) - return; - - WebPoint point(arguments[1].toInt32(), arguments[2].toInt32()); - unsigned maxLength = arguments[3].toInt32(); - - WebSurroundingText surroundingText; - surroundingText.initialize(node, point, maxLength); - if (surroundingText.isNull()) - return; - - result->set(surroundingText.textContent().utf8()); -} diff --git a/Tools/DumpRenderTree/chromium/DRTTestRunner.h b/Tools/DumpRenderTree/chromium/DRTTestRunner.h index c4cb7ace8..9f02e1c53 100644 --- a/Tools/DumpRenderTree/chromium/DRTTestRunner.h +++ b/Tools/DumpRenderTree/chromium/DRTTestRunner.h @@ -63,7 +63,10 @@ class ScopedTempDirectory; class TestShell; -class DRTTestRunner : public TestRunner { +using WebTestRunner::CppArgumentList; +using WebTestRunner::CppVariant; + +class DRTTestRunner : public WebTestRunner::TestRunner { public: // Builds the property and method lists needed to bind this class to a JS // object. @@ -76,13 +79,6 @@ public: // It takes an optional argument, whether to dump pixels results or not. void dumpAsText(const CppArgumentList&, CppVariant*); - // This function should set a flag that tells the test_shell to print a line - // of descriptive text for each database command. It should take no - // arguments, and ignore any that may be present. However, at the moment, we - // don't have any DB function that prints messages, so for now this function - // doesn't do anything. - void dumpDatabaseCallbacks(const CppArgumentList&, CppVariant*); - // This function sets a flag that tells the test_shell to print a line of // descriptive text for each editing command. It takes no arguments, and // ignores any that may be present. @@ -136,11 +132,6 @@ public: // It takes no arguments, and ignores any that may be present. void dumpCreateView(const CppArgumentList&, CppVariant*); - // When called with a boolean argument, this sets a flag that controls - // whether content-editable elements accept editing focus when an editing - // attempt is made. It ignores any additional arguments. - void setAcceptsEditing(const CppArgumentList&, CppVariant*); - // Functions for dealing with windows. By default we block all new windows. void windowCount(const CppArgumentList&, CppVariant*); void setCanOpenWindows(const CppArgumentList&, CppVariant*); @@ -161,16 +152,9 @@ public: void queueLoad(const CppArgumentList&, CppVariant*); void queueLoadHTMLString(const CppArgumentList&, CppVariant*); - // Although this is named "objC" to match the Mac version, it actually tests - // the identity of its two arguments in C++. - void objCIdentityIsEqual(const CppArgumentList&, CppVariant*); - // Changes the cookie policy from the default to allow all cookies. void setAlwaysAcceptCookies(const CppArgumentList&, CppVariant*); - // Changes asynchronous spellchecking flag on the settings. - void setAsynchronousSpellCheckingEnabled(const CppArgumentList&, CppVariant*); - // Shows DevTools window. void showWebInspector(const CppArgumentList&, CppVariant*); void closeWebInspector(const CppArgumentList&, CppVariant*); @@ -178,9 +162,6 @@ public: // Gives focus to the window. void setWindowIsKey(const CppArgumentList&, CppVariant*); - // Method that controls whether pressing Tab key cycles through page elements - // or inserts a '\t' char in text area - void setTabKeyCyclesThroughElements(const CppArgumentList&, CppVariant*); // Passes through to WebPreferences which allows the user to have a custom // style sheet. @@ -190,13 +171,6 @@ public: // Passes this preference through to WebSettings. void setAuthorAndUserStylesEnabled(const CppArgumentList&, CppVariant*); - // Puts Webkit in "dashboard compatibility mode", which is used in obscure - // Mac-only circumstances. It's not really necessary, and will most likely - // never be used by Chrome, but some layout tests depend on its presence. - void setUseDashboardCompatibilityMode(const CppArgumentList&, CppVariant*); - - void setScrollbarPolicy(const CppArgumentList&, CppVariant*); - // Causes navigation actions just printout the intended navigation instead // of taking you to the page. This is used for cases like mailto, where you // don't actually want to open the mail program. @@ -217,16 +191,6 @@ public: // Converts a URL starting with file:///tmp/ to the local mapping. void pathToLocalResource(const CppArgumentList&, CppVariant*); - // Sets a bool such that when a drag is started, we fill the drag clipboard - // with a fake file object. - void addFileToPasteboardOnDrag(const CppArgumentList&, CppVariant*); - - // Executes an internal command (superset of document.execCommand() commands). - void execCommand(const CppArgumentList&, CppVariant*); - - // Checks if an internal command is currently available. - void isCommandEnabled(const CppArgumentList&, CppVariant*); - // Set the WebPreference that controls webkit's popup blocking. void setPopupBlockingEnabled(const CppArgumentList&, CppVariant*); @@ -239,52 +203,28 @@ public: // Enable or disable trailing whitespace selection on double click. void setSelectTrailingWhitespaceEnabled(const CppArgumentList&, CppVariant*); - - void pauseAnimationAtTimeOnElementWithId(const CppArgumentList&, CppVariant*); - void pauseTransitionAtTimeOnElementWithId(const CppArgumentList&, CppVariant*); - void elementDoesAutoCompleteForElementWithId(const CppArgumentList&, CppVariant*); void enableAutoResizeMode(const CppArgumentList&, CppVariant*); void disableAutoResizeMode(const CppArgumentList&, CppVariant*); - void numberOfActiveAnimations(const CppArgumentList&, CppVariant*); - void disableImageLoading(const CppArgumentList&, CppVariant*); - void setIconDatabaseEnabled(const CppArgumentList&, CppVariant*); void dumpSelectionRect(const CppArgumentList&, CppVariant*); #if ENABLE(NOTIFICATIONS) // Grants permission for desktop notifications to an origin void grantWebNotificationPermission(const CppArgumentList&, CppVariant*); - void denyWebNotificationPermission(const CppArgumentList&, CppVariant*); - void removeAllWebNotificationPermissions(const CppArgumentList&, CppVariant*); - void simulateWebNotificationClick(const CppArgumentList&, CppVariant*); // Simulates a click on a desktop notification. void simulateLegacyWebNotificationClick(const CppArgumentList&, CppVariant*); #endif - void setDomainRelaxationForbiddenForURLScheme(const CppArgumentList&, CppVariant*); void setDeferMainResourceDataLoad(const CppArgumentList&, CppVariant*); // Deals with Web Audio WAV file data. void setAudioData(const CppArgumentList&, CppVariant*); const WebKit::WebArrayBufferView& audioData() const { return m_audioData; } - // The following are only stubs. - // FIXME: Implement any of these that are needed to pass the layout tests. - void dumpAsWebArchive(const CppArgumentList&, CppVariant*); void dumpTitleChanges(const CppArgumentList&, CppVariant*); - void setMainFrameIsFirstResponder(const CppArgumentList&, CppVariant*); void display(const CppArgumentList&, CppVariant*); void displayInvalidatedRegion(const CppArgumentList&, CppVariant*); void testRepaint(const CppArgumentList&, CppVariant*); void repaintSweepHorizontally(const CppArgumentList&, CppVariant*); - void clearBackForwardList(const CppArgumentList&, CppVariant*); - void keepWebHistory(const CppArgumentList&, CppVariant*); - void storeWebScriptObject(const CppArgumentList&, CppVariant*); - void accessStoredWebScriptObject(const CppArgumentList&, CppVariant*); - void objCClassNameOf(const CppArgumentList&, CppVariant*); - void addDisallowedURL(const CppArgumentList&, CppVariant*); - void callShouldCloseOnWebView(const CppArgumentList&, CppVariant*); - void setCallCloseOnWebViews(const CppArgumentList&, CppVariant*); - void setPrivateBrowsingEnabled(const CppArgumentList&, CppVariant*); void setJavaScriptCanAccessClipboard(const CppArgumentList&, CppVariant*); void setXSSAuditorEnabled(const CppArgumentList&, CppVariant*); @@ -294,32 +234,6 @@ public: void setAllowFileAccessFromFileURLs(const CppArgumentList&, CppVariant*); void setAllowRunningOfInsecureContent(const CppArgumentList&, CppVariant*); - void evaluateScriptInIsolatedWorldAndReturnValue(const CppArgumentList&, CppVariant*); - void evaluateScriptInIsolatedWorld(const CppArgumentList&, CppVariant*); - void setIsolatedWorldSecurityOrigin(const CppArgumentList&, CppVariant*); - void setIsolatedWorldContentSecurityPolicy(const CppArgumentList&, CppVariant*); - - // The fallback method is called when a nonexistent method is called on - // the layout test controller object. - // It is usefull to catch typos in the JavaScript code (a few layout tests - // do have typos in them) and it allows the script to continue running in - // that case (as the Mac does). - void fallbackMethod(const CppArgumentList&, CppVariant*); - - // Allows layout tests to manage origins' whitelisting. - void addOriginAccessWhitelistEntry(const CppArgumentList&, CppVariant*); - void removeOriginAccessWhitelistEntry(const CppArgumentList&, CppVariant*); - - // Clears all application caches. - void clearAllApplicationCaches(const CppArgumentList&, CppVariant*); - // Clears an application cache for an origin. - void clearApplicationCacheForOrigin(const CppArgumentList&, CppVariant*); - // Returns origins that have application caches. - void originsWithApplicationCache(const CppArgumentList&, CppVariant*); - // Sets the application cache quota for the localhost origin. - void setApplicationCacheOriginQuota(const CppArgumentList&, CppVariant*); - // Returns disk usage by all application caches for an origin. - void applicationCacheDiskUsageForOrigin(const CppArgumentList&, CppVariant*); // Clears all databases. void clearAllDatabases(const CppArgumentList&, CppVariant*); @@ -333,23 +247,12 @@ public: // Causes layout to happen as if targetted to printed pages. void setPrinting(const CppArgumentList&, CppVariant*); - // Returns true if the current page box has custom page size style for - // printing. - void hasCustomPageSizeStyle(const CppArgumentList&, CppVariant*); - // Gets the number of geolocation permissions requests pending. void numberOfPendingGeolocationPermissionRequests(const CppArgumentList&, CppVariant*); // Allows layout tests to exec scripts at WebInspector side. void evaluateInWebInspector(const CppArgumentList&, CppVariant*); - // Forces the selection colors for testing under Linux. - void forceRedSelectionColors(const CppArgumentList&, CppVariant*); - - // Adds a user script or user style sheet to be injected into new documents. - void addUserScript(const CppArgumentList&, CppVariant*); - void addUserStyleSheet(const CppArgumentList&, CppVariant*); - // DeviceOrientation related functions void setMockDeviceOrientation(const CppArgumentList&, CppVariant*); @@ -358,9 +261,6 @@ public: void setMockGeolocationPosition(const CppArgumentList&, CppVariant*); void setMockGeolocationPositionUnavailableError(const CppArgumentList&, CppVariant*); - // Empty stub method to keep parity with object model exposed by global DRTTestRunner. - void abortModal(const CppArgumentList&, CppVariant*); - // Speech input related functions. #if ENABLE(INPUT_SPEECH) void addMockSpeechInputResult(const CppArgumentList&, CppVariant*); @@ -371,30 +271,6 @@ public: void setMockSpeechRecognitionError(const CppArgumentList&, CppVariant*); void wasMockSpeechRecognitionAborted(const CppArgumentList&, CppVariant*); #endif - void startSpeechInput(const CppArgumentList&, CppVariant*); - - void loseCompositorContext(const CppArgumentList& args, CppVariant* result); - - void markerTextForListItem(const CppArgumentList&, CppVariant*); - void findString(const CppArgumentList&, CppVariant*); - - void setMinimumTimerInterval(const CppArgumentList&, CppVariant*); - - // Expects the first argument to be an input element and the second argument to be a boolean. - // Forwards the setAutofilled() call to the element. - void setAutofilled(const CppArgumentList&, CppVariant*); - - // Expects the first argument to be an input element and the second argument to be a string value. - // Forwards the setValueForUser() call to the element. - void setValueForUser(const CppArgumentList&, CppVariant*); - - // LocalStorage origin-related - void deleteAllLocalStorage(const CppArgumentList&, CppVariant*); - void originsWithLocalStorage(const CppArgumentList&, CppVariant*); - void deleteLocalStorageForOrigin(const CppArgumentList&, CppVariant*); - void localStorageDiskUsageForOrigin(const CppArgumentList&, CppVariant*); - void observeStorageTrackerNotifications(const CppArgumentList&, CppVariant*); - void syncLocalStorage(const CppArgumentList&, CppVariant*); // WebPermissionClient related. void setImagesAllowed(const CppArgumentList&, CppVariant*); @@ -406,23 +282,8 @@ public: // Enable or disable plugins. void setPluginsEnabled(const CppArgumentList&, CppVariant*); - // Switch the visibility of the page. - void setPageVisibility(const CppArgumentList&, CppVariant*); - void resetPageVisibility(const CppArgumentList&, CppVariant*); - - // Changes the direction of the focused element. - void setTextDirection(const CppArgumentList&, CppVariant*); - void setShouldStayOnPageAfterHandlingBeforeUnload(const CppArgumentList&, CppVariant*); - void enableFixedLayoutMode(const CppArgumentList&, CppVariant*); - void setFixedLayoutSize(const CppArgumentList&, CppVariant*); - - void selectionAsMarkup(const CppArgumentList&, CppVariant*); - - // Switch the link detection. - void setAutomaticLinkDetectionEnabled(bool); - #if ENABLE(POINTER_LOCK) void didAcquirePointerLock(const CppArgumentList&, CppVariant*); void didNotAcquirePointerLock(const CppArgumentList&, CppVariant*); @@ -431,8 +292,6 @@ public: void setPointerLockWillRespondAsynchronously(const CppArgumentList&, CppVariant*); #endif - void workerThreadCount(CppVariant*); - // Expects one string argument for sending successful result, zero // arguments for sending a failure result. void sendWebIntentResponse(const CppArgumentList&, CppVariant*); @@ -440,22 +299,9 @@ public: // Cause the web intent to be delivered to this context. void deliverWebIntent(const CppArgumentList&, CppVariant*); - // Enables or disables subpixel positioning (i.e. fractional X positions for - // glyphs) in text rendering on Linux. Since this method changes global - // settings, tests that call it must use their own custom font family for - // all text that they render. If not, an already-cached style will be used, - // resulting in the changed setting being ignored. - void setTextSubpixelPositioning(const CppArgumentList&, CppVariant*); - // Used to set the device scale factor. void setBackingScaleFactor(const CppArgumentList&, CppVariant*); - // Retrieves the text surrounding a position in a text node. - // Expects the first argument to be a text node, the second and third to be - // point coordinates relative to the node and the fourth the maximum text - // length to retrieve. - void textSurroundingNode(const CppArgumentList&, CppVariant*); - public: // The following methods are not exposed to JavaScript. void setWorkQueueFrozen(bool frozen) { m_workQueue.setFrozen(frozen); } @@ -484,9 +330,7 @@ public: bool shouldGeneratePixelResults() { return m_generatePixelResults; } void setShouldGeneratePixelResults(bool value) { m_generatePixelResults = value; } bool shouldDumpCreateView() { return m_dumpCreateView; } - bool acceptsEditing() { return m_acceptsEditing; } bool canOpenWindows() { return m_canOpenWindows; } - bool shouldAddFileToPasteboard() { return m_shouldAddFileToPasteboard; } bool stopProvisionalFrameLoads() { return m_stopProvisionalFrameLoads; } bool deferMainResourceDataLoad() { return m_deferMainResourceDataLoad; } void setShowDebugLayerTree(bool value) { m_showDebugLayerTree = value; } @@ -506,9 +350,6 @@ public: bool testRepaint() const { return m_testRepaint; } bool sweepHorizontally() const { return m_sweepHorizontally; } - void setHasCustomFullScreenBehavior(const CppArgumentList&, CppVariant*); - bool hasCustomFullScreenBehavior() const { return m_hasCustomFullScreenBehavior; } - // Called by the webview delegate when the toplevel frame load is done. void locationChangeDone(); @@ -567,14 +408,6 @@ private: bool m_frozen; DRTTestRunner* m_controller; }; - - // Support for overridePreference. - bool cppVariantToBool(const CppVariant&); - int32_t cppVariantToInt32(const CppVariant&); - WebKit::WebString cppVariantToWebString(const CppVariant&); - Vector<WebKit::WebString> cppVariantToWebStringArray(const CppVariant&); - - void logErrorToConsole(const std::string&); void completeNotifyDone(bool isTimeout); class NotifyDoneTimedOutTask: public WebTestRunner::WebMethodTask<DRTTestRunner> { public: @@ -582,12 +415,6 @@ private: virtual void runIfValid() { m_object->completeNotifyDone(true); } }; - - bool pauseAnimationAtTimeOnElementWithId(const WebKit::WebString& animationName, double time, const WebKit::WebString& elementId); - bool pauseTransitionAtTimeOnElementWithId(const WebKit::WebString& propertyName, double time, const WebKit::WebString& elementId); - bool elementDoesAutoCompleteForElementWithId(const WebKit::WebString&); - int numberOfActiveAnimations(); - // Used for test timeouts. WebTestRunner::WebTaskList m_taskList; @@ -658,11 +485,6 @@ private: // is invoked. bool m_dumpCreateView; - // If true, the element will be treated as editable. This value is returned - // from various editing callbacks that are called just before edit operations - // are allowed. - bool m_acceptsEditing; - // If true, new windows can be opened via javascript or by plugins. By // default, set to false and can be toggled to true using // setCanOpenWindows(). @@ -680,9 +502,6 @@ private: // a series of 1px-wide, view-tall paints across the width of the view. bool m_sweepHorizontally; - // If true and a drag starts, adds a file to the drag&drop clipboard. - bool m_shouldAddFileToPasteboard; - // If true, stops provisional frame loads during the // DidStartProvisionalLoadForFrame callback. bool m_stopProvisionalFrameLoads; @@ -701,17 +520,12 @@ private: WorkQueue m_workQueue; - CppVariant m_globalFlag; - // Bound variable counting the number of top URLs visited. CppVariant m_webHistoryItemCount; // Bound variable tracking the directionality of the <title> tag. CppVariant m_titleTextDirection; - // Bound variable to return the name of this platform (chromium). - CppVariant m_platformName; - // Bound variable to set whether postMessages should be intercepted or not CppVariant m_interceptPostMessage; @@ -724,10 +538,6 @@ private: OwnPtr<WebKit::WebDeliveredIntentClient> m_intentClient; bool m_shouldStayOnPageAfterHandlingBeforeUnload; - - // If true, calls to WebViewHost::enter/exitFullScreenNow will not result in - // calls to Document::will/did/Enter/ExitFullScreen. - bool m_hasCustomFullScreenBehavior; }; #endif // DRTTestRunner_h diff --git a/Tools/DumpRenderTree/chromium/MockWebMediaStreamCenter.cpp b/Tools/DumpRenderTree/chromium/MockWebMediaStreamCenter.cpp index 4410ef2f9..b7178f099 100644 --- a/Tools/DumpRenderTree/chromium/MockWebMediaStreamCenter.cpp +++ b/Tools/DumpRenderTree/chromium/MockWebMediaStreamCenter.cpp @@ -33,13 +33,11 @@ #include "MockWebMediaStreamCenter.h" -#include <public/WebICECandidateDescriptor.h> #include <public/WebMediaStreamCenterClient.h> #include <public/WebMediaStreamComponent.h> #include <public/WebMediaStreamDescriptor.h> #include <public/WebMediaStreamSource.h> #include <public/WebMediaStreamSourcesRequest.h> -#include <public/WebSessionDescriptionDescriptor.h> #include <public/WebVector.h> using namespace WebKit; @@ -91,24 +89,4 @@ void MockWebMediaStreamCenter::didCreateMediaStream(WebMediaStreamDescriptor&) { } -WebString MockWebMediaStreamCenter::constructSDP(const WebICECandidateDescriptor& iceCandidate) -{ - string16 result = iceCandidate.label(); - result += WebString(":"); - result += iceCandidate.candidateLine(); - result += WebString(";"); - return result; -} - -WebString MockWebMediaStreamCenter::constructSDP(const WebSessionDescriptionDescriptor& sessionDescription) -{ - string16 result = sessionDescription.initialSDP(); - result += WebString(";"); - for (size_t i = 0; i < sessionDescription.numberOfAddedCandidates(); ++i) { - result += constructSDP(sessionDescription.candidate(i)); - result += WebString(";"); - } - return result; -} - #endif // ENABLE(MEDIA_STREAM) diff --git a/Tools/DumpRenderTree/chromium/MockWebMediaStreamCenter.h b/Tools/DumpRenderTree/chromium/MockWebMediaStreamCenter.h index 286dc3f8d..7d532e743 100644 --- a/Tools/DumpRenderTree/chromium/MockWebMediaStreamCenter.h +++ b/Tools/DumpRenderTree/chromium/MockWebMediaStreamCenter.h @@ -49,8 +49,6 @@ public: virtual bool didRemoveMediaStreamTrack(const WebKit::WebMediaStreamDescriptor&, const WebKit::WebMediaStreamComponent&) OVERRIDE; virtual void didStopLocalMediaStream(const WebKit::WebMediaStreamDescriptor&) OVERRIDE; virtual void didCreateMediaStream(WebKit::WebMediaStreamDescriptor&) OVERRIDE; - virtual WebKit::WebString constructSDP(const WebKit::WebICECandidateDescriptor&) OVERRIDE; - virtual WebKit::WebString constructSDP(const WebKit::WebSessionDescriptionDescriptor&) OVERRIDE; private: MockWebMediaStreamCenter() { } diff --git a/Tools/DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp b/Tools/DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp index ca1e6043f..cfd76de74 100644 --- a/Tools/DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp +++ b/Tools/DumpRenderTree/chromium/MockWebRTCPeerConnectionHandler.cpp @@ -337,6 +337,11 @@ bool MockWebRTCPeerConnectionHandler::openDataChannel(const WebRTCDataChannel& d if (m_stopped) return false; + WebRTCDataChannel remoteDataChannel; + remoteDataChannel.initialize("MockRemoteDataChannel", dataChannel.reliable()); + remoteDataChannel.readyStateChanged(WebRTCDataChannel::ReadyStateOpen); + m_client->didAddRemoteDataChannel(remoteDataChannel); + postTask(new DataChannelReadyStateTask(this, dataChannel, WebRTCDataChannel::ReadyStateOpen)); return true; } @@ -351,7 +356,7 @@ bool MockWebRTCPeerConnectionHandler::sendStringData(const WebRTCDataChannel& da if (m_stopped) return false; - postTask(new StringDataTask(this, dataChannel, data)); + dataChannel.dataArrived(data); return true; } @@ -360,7 +365,7 @@ bool MockWebRTCPeerConnectionHandler::sendRawData(const WebRTCDataChannel& dataC if (m_stopped) return false; - postTask(new CharPtrDataTask(this, dataChannel, data, length)); + dataChannel.dataArrived(data, length); return true; } diff --git a/Tools/DumpRenderTree/chromium/TestRunner/public/WebTestProxy.h b/Tools/DumpRenderTree/chromium/TestRunner/public/WebTestProxy.h new file mode 100644 index 000000000..b4a593cee --- /dev/null +++ b/Tools/DumpRenderTree/chromium/TestRunner/public/WebTestProxy.h @@ -0,0 +1,143 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebTestProxy_h +#define WebTestProxy_h + +#include "Platform/chromium/public/WebRect.h" +#include "WebKit/chromium/public/WebAccessibilityNotification.h" +#include "WebKit/chromium/public/WebDragOperation.h" +#include "WebKit/chromium/public/WebNavigationPolicy.h" + +namespace WebKit { +class WebAccessibilityObject; +class WebDragData; +class WebFrame; +class WebImage; +struct WebPoint; +struct WebSize; +} + +namespace WebTestRunner { + +class WebTestDelegate; +class WebTestInterfaces; + +class WebTestProxyBase { +public: + void setInterfaces(WebTestInterfaces*); + void setDelegate(WebTestDelegate*); + + void setPaintRect(const WebKit::WebRect&); + WebKit::WebRect paintRect() const; + +protected: + WebTestProxyBase(); + ~WebTestProxyBase(); + + void didInvalidateRect(const WebKit::WebRect&); + void didScrollRect(int, int, const WebKit::WebRect&); + void scheduleComposite(); + void scheduleAnimation(); + void setWindowRect(const WebKit::WebRect&); + void show(WebKit::WebNavigationPolicy); + void didAutoResize(const WebKit::WebSize&); + void postAccessibilityNotification(const WebKit::WebAccessibilityObject&, WebKit::WebAccessibilityNotification); + void startDragging(WebKit::WebFrame*, const WebKit::WebDragData&, WebKit::WebDragOperationsMask, const WebKit::WebImage&, const WebKit::WebPoint&); + +private: + WebTestInterfaces* m_testInterfaces; + WebTestDelegate* m_delegate; + + WebKit::WebRect m_paintRect; +}; + +// Use this template to inject methods into your WebViewClient implementation +// required for the running layout tests. +template<class WebViewClientImpl, typename T> +class WebTestProxy : public WebViewClientImpl, public WebTestProxyBase { +public: + explicit WebTestProxy(T t) + : WebViewClientImpl(t) + { + } + + virtual ~WebTestProxy() { } + + virtual void didInvalidateRect(const WebKit::WebRect& rect) + { + WebTestProxyBase::didInvalidateRect(rect); + WebViewClientImpl::didInvalidateRect(rect); + } + virtual void didScrollRect(int dx, int dy, const WebKit::WebRect& clipRect) + { + WebTestProxyBase::didScrollRect(dx, dy, clipRect); + WebViewClientImpl::didScrollRect(dx, dy, clipRect); + } + virtual void scheduleComposite() + { + WebTestProxyBase::scheduleComposite(); + WebViewClientImpl::scheduleComposite(); + } + virtual void scheduleAnimation() + { + WebTestProxyBase::scheduleAnimation(); + WebViewClientImpl::scheduleAnimation(); + } + virtual void setWindowRect(const WebKit::WebRect& rect) + { + WebTestProxyBase::setWindowRect(rect); + WebViewClientImpl::setWindowRect(rect); + } + virtual void show(WebKit::WebNavigationPolicy policy) + { + WebTestProxyBase::show(policy); + WebViewClientImpl::show(policy); + } + virtual void didAutoResize(const WebKit::WebSize& newSize) + { + WebTestProxyBase::didAutoResize(newSize); + WebViewClientImpl::didAutoResize(newSize); + } + virtual void postAccessibilityNotification(const WebKit::WebAccessibilityObject& object, WebKit::WebAccessibilityNotification notification) + { + WebTestProxyBase::postAccessibilityNotification(object, notification); + WebViewClientImpl::postAccessibilityNotification(object, notification); + } + virtual void startDragging(WebKit::WebFrame* frame, const WebKit::WebDragData& data, WebKit::WebDragOperationsMask mask, const WebKit::WebImage& image, const WebKit::WebPoint& point) + { + WebTestProxyBase::startDragging(frame, data, mask, image, point); + WebViewClientImpl::startDragging(frame, data, mask, image, point); + } +}; + +} + +#endif // WebTestProxy_h diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.h b/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.h index 35bf06c56..a9728c615 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.h +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.h @@ -40,10 +40,10 @@ class WebFrame; class WebView; } -class TestDelegate; - namespace WebTestRunner { +class TestDelegate; + class AccessibilityController : public CppBoundClass { public: AccessibilityController(); diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityUIElementChromium.cpp b/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityUIElementChromium.cpp index 2157ddb69..7b8f6fbd1 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityUIElementChromium.cpp +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityUIElementChromium.cpp @@ -42,9 +42,13 @@ using namespace WebKit; using namespace std; +namespace WebTestRunner { + +namespace { + // Map role value to string, matching Safari/Mac platform implementation to // avoid rebaselining layout tests. -static string roleToString(WebAccessibilityRole role) +string roleToString(WebAccessibilityRole role) { string result = "AXRole: AX"; switch (role) { @@ -347,6 +351,8 @@ private: string m_attributes; }; +} + AccessibilityUIElement::AccessibilityUIElement(const WebAccessibilityObject& object, Factory* factory) : m_accessibilityObject(object) , m_factory(factory) @@ -972,3 +978,5 @@ AccessibilityUIElement* AccessibilityUIElementList::createRoot(const WebAccessib m_elements.append(element); return element; } + +} diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityUIElementChromium.h b/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityUIElementChromium.h index d9e73e57e..4dc479e93 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityUIElementChromium.h +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityUIElementChromium.h @@ -36,6 +36,8 @@ #include <vector> #include <wtf/Vector.h> +namespace WebTestRunner { + class AccessibilityUIElement : public CppBoundClass { public: class Factory { @@ -166,4 +168,6 @@ private: ElementList m_elements; }; +} + #endif // AccessibilityUIElementChromium_h diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/CppBoundClass.cpp b/Tools/DumpRenderTree/chromium/TestRunner/src/CppBoundClass.cpp index 1b29d2b0f..930de6113 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/CppBoundClass.cpp +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/CppBoundClass.cpp @@ -51,6 +51,10 @@ using namespace WebKit; using namespace std; +namespace WebTestRunner { + +namespace { + class CppVariantPropertyCallback : public CppBoundClass::PropertyCallback { public: CppVariantPropertyCallback(CppVariant* value) : m_value(value) { } @@ -90,6 +94,8 @@ private: OwnPtr<CppBoundClass::GetterCallback> m_callback; }; +} + // Our special NPObject type. We extend an NPObject with a pointer to a // CppBoundClass, which is just a C++ interface that we forward all NPObject // callbacks to. @@ -350,3 +356,5 @@ void CppBoundClass::bindToJavascript(WebFrame* frame, const WebString& classname frame->bindToWindowObject(classname, NPVARIANT_TO_OBJECT(*getAsCppVariant())); m_boundToFrame = true; } + +} diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/CppBoundClass.h b/Tools/DumpRenderTree/chromium/TestRunner/src/CppBoundClass.h index 4fb5361e1..54af6ddce 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/CppBoundClass.h +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/CppBoundClass.h @@ -55,6 +55,8 @@ class WebFrame; class WebString; } +namespace WebTestRunner { + typedef Vector<CppVariant> CppArgumentList; // CppBoundClass lets you map Javascript method calls and property accesses @@ -242,4 +244,6 @@ private: bool m_boundToFrame; }; +} + #endif // CppBoundClass_h diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/CppVariant.cpp b/Tools/DumpRenderTree/chromium/TestRunner/src/CppVariant.cpp index b587d75aa..4d2856e74 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/CppVariant.cpp +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/CppVariant.cpp @@ -39,6 +39,8 @@ using namespace WebKit; using namespace std; +namespace WebTestRunner { + CppVariant::CppVariant() { type = NPVariantType_Null; @@ -319,3 +321,5 @@ bool CppVariant::invokeDefault(const CppVariant* arguments, uint32_t argumentCou result.set(r); return status; } + +} diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/CppVariant.h b/Tools/DumpRenderTree/chromium/TestRunner/src/CppVariant.h index 47fd466af..e82a70b66 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/CppVariant.h +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/CppVariant.h @@ -46,6 +46,8 @@ #include <string> #include <wtf/Vector.h> +namespace WebTestRunner { + class CppVariant : public NPVariant { public: CppVariant(); @@ -137,4 +139,6 @@ public: uint32_t argumentCount, CppVariant& result) const; }; +} + #endif // CppVariant_h diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/EventSender.cpp b/Tools/DumpRenderTree/chromium/TestRunner/src/EventSender.cpp index 77fcb76e8..171e25ddb 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/EventSender.cpp +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/EventSender.cpp @@ -836,14 +836,19 @@ void EventSender::contextClick(const CppArgumentList& arguments, CppVariant* res // Generate right mouse down and up. WebMouseEvent event; - pressedButton = WebMouseEvent::ButtonRight; + // This is a hack to work around only allowing a single pressed button since we want to + // test the case where both the left and right mouse buttons are pressed. + if (pressedButton == WebMouseEvent::ButtonNone) + pressedButton = WebMouseEvent::ButtonRight; initMouseEvent(WebInputEvent::MouseDown, WebMouseEvent::ButtonRight, lastMousePos, &event, getCurrentEventTimeSec(m_delegate)); webview()->handleInputEvent(event); +#if OS(WINDOWS) initMouseEvent(WebInputEvent::MouseUp, WebMouseEvent::ButtonRight, lastMousePos, &event, getCurrentEventTimeSec(m_delegate)); webview()->handleInputEvent(event); pressedButton = WebMouseEvent::ButtonNone; +#endif WebContextMenuData* lastContextMenu = m_delegate->lastContextMenuData(); result->set(WebBindings::makeStringArray(makeMenuItemStringsFor(lastContextMenu, m_delegate))); diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/EventSender.h b/Tools/DumpRenderTree/chromium/TestRunner/src/EventSender.h index d07e14cc6..c5d742b5f 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/EventSender.h +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/EventSender.h @@ -48,10 +48,10 @@ class WebDragData; class WebView; } -class TestDelegate; - namespace WebTestRunner { +class TestDelegate; + class EventSender : public CppBoundClass { public: EventSender(); @@ -69,6 +69,7 @@ public: void dumpFilenameBeingDragged(const CppArgumentList&, CppVariant*); // JS callback methods. + void contextClick(const CppArgumentList&, CppVariant*); void mouseDown(const CppArgumentList&, CppVariant*); void mouseUp(const CppArgumentList&, CppVariant*); void mouseMoveTo(const CppArgumentList&, CppVariant*); @@ -114,7 +115,6 @@ public: void gestureEvent(WebKit::WebInputEvent::Type, const CppArgumentList&); // Unimplemented stubs - void contextClick(const CppArgumentList&, CppVariant*); void enableDOMUIEventLogging(const CppArgumentList&, CppVariant*); void fireKeyboardEventsToElement(const CppArgumentList&, CppVariant*); void clearKillRing(const CppArgumentList&, CppVariant*); diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/GamepadController.cpp b/Tools/DumpRenderTree/chromium/TestRunner/src/GamepadController.cpp index 282ce44de..e9c246af2 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/GamepadController.cpp +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/GamepadController.cpp @@ -34,6 +34,8 @@ using namespace WebKit; +namespace WebTestRunner { + GamepadController::GamepadController() { bindMethod("connect", &GamepadController::connect); @@ -193,3 +195,5 @@ void GamepadController::fallbackCallback(const CppArgumentList&, CppVariant* res m_delegate->printMessage("CONSOLE MESSAGE: JavaScript ERROR: unknown method called on GamepadController\n"); result->setNull(); } + +} diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/GamepadController.h b/Tools/DumpRenderTree/chromium/TestRunner/src/GamepadController.h index 4e65e922f..9058c702d 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/GamepadController.h +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/GamepadController.h @@ -34,13 +34,15 @@ #include "CppBoundClass.h" #include "platform/WebGamepads.h" -class TestDelegate; - namespace WebKit { class WebGamepads; class WebFrame; } +namespace WebTestRunner { + +class TestDelegate; + class GamepadController : public CppBoundClass { public: GamepadController(); @@ -65,4 +67,6 @@ private: TestDelegate* m_delegate; }; +} + #endif // GamepadController_h diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/TestDelegate.h b/Tools/DumpRenderTree/chromium/TestRunner/src/TestDelegate.h index 0498fcb3f..f8eceb6d0 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/TestDelegate.h +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/TestDelegate.h @@ -40,8 +40,8 @@ class WebGamepads; } namespace WebTestRunner { + class WebTask; -} class TestDelegate { public: @@ -52,11 +52,13 @@ public: virtual WebKit::WebContextMenuData* lastContextMenuData() const = 0; virtual void setGamepadData(const WebKit::WebGamepads&) = 0; virtual void printMessage(const std::string& message) = 0; - virtual void postTask(WebTestRunner::WebTask*) = 0; - virtual void postDelayedTask(WebTestRunner::WebTask*, long long ms) = 0; + virtual void postTask(WebTask*) = 0; + virtual void postDelayedTask(WebTask*, long long ms) = 0; virtual WebKit::WebString registerIsolatedFileSystem(const WebKit::WebVector<WebKit::WebString>& absoluteFilenames) = 0; virtual long long getCurrentTimeInMillisecond() = 0; virtual WebKit::WebString getAbsoluteWebStringFromUTF8Path(const std::string& path) = 0; }; +} + #endif // TestDelegate_h diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/TestInterfaces.cpp b/Tools/DumpRenderTree/chromium/TestRunner/src/TestInterfaces.cpp index 8959bb1ba..f08da5d40 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/TestInterfaces.cpp +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/TestInterfaces.cpp @@ -37,12 +37,12 @@ #include "TextInputController.h" #include "platform/WebString.h" -using WebTestRunner::AccessibilityController; -using WebTestRunner::EventSender; using WebKit::WebFrame; using WebKit::WebString; using WebKit::WebView; +namespace WebTestRunner { + TestInterfaces::TestInterfaces() { m_accessibilityController = adoptPtr(new AccessibilityController()); @@ -105,3 +105,5 @@ EventSender* TestInterfaces::eventSender() { return m_eventSender.get(); } + +} diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/TestInterfaces.h b/Tools/DumpRenderTree/chromium/TestRunner/src/TestInterfaces.h index 228658c22..a7da43283 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/TestInterfaces.h +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/TestInterfaces.h @@ -39,10 +39,9 @@ class WebView; } namespace WebTestRunner { + class AccessibilityController; class EventSender; -} - class GamepadController; class TestDelegate; class TextInputController; @@ -57,14 +56,16 @@ public: void bindTo(WebKit::WebFrame*); void resetAll(); - WebTestRunner::AccessibilityController* accessibilityController(); - WebTestRunner::EventSender* eventSender(); + AccessibilityController* accessibilityController(); + EventSender* eventSender(); private: - OwnPtr<WebTestRunner::AccessibilityController> m_accessibilityController; - OwnPtr<WebTestRunner::EventSender> m_eventSender; + OwnPtr<AccessibilityController> m_accessibilityController; + OwnPtr<EventSender> m_eventSender; OwnPtr<GamepadController> m_gamepadController; OwnPtr<TextInputController> m_textInputController; }; +} + #endif // TestInterfaces_h diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/TestRunner.cpp b/Tools/DumpRenderTree/chromium/TestRunner/src/TestRunner.cpp index f0da79831..37078927d 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/TestRunner.cpp +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/TestRunner.cpp @@ -32,6 +32,714 @@ #include "config.h" #include "TestRunner.h" +#include "WebAnimationController.h" +#include "WebBindings.h" +#include "WebDocument.h" +#include "WebElement.h" +#include "WebFindOptions.h" +#include "WebFrame.h" +#include "WebInputElement.h" +#include "WebScriptSource.h" +#include "WebSecurityPolicy.h" +#include "WebSettings.h" +#include "WebSurroundingText.h" +#include "WebTestDelegate.h" +#include "WebView.h" +#include "WebWorkerInfo.h" +#include "platform/WebPoint.h" +#include "v8/include/v8.h" + +#if OS(LINUX) || OS(ANDROID) +#include "linux/WebFontRendering.h" +#endif + +using namespace WebKit; +using namespace std; + +namespace WebTestRunner { + TestRunner::TestRunner() + : m_delegate(0) + , m_webView(0) +{ + // Methods implemented in terms of chromium's public WebKit API. + bindMethod("setTabKeyCyclesThroughElements", &TestRunner::setTabKeyCyclesThroughElements); + bindMethod("setAsynchronousSpellCheckingEnabled", &TestRunner::setAsynchronousSpellCheckingEnabled); + bindMethod("execCommand", &TestRunner::execCommand); + bindMethod("isCommandEnabled", &TestRunner::isCommandEnabled); + bindMethod("pauseAnimationAtTimeOnElementWithId", &TestRunner::pauseAnimationAtTimeOnElementWithId); + bindMethod("pauseTransitionAtTimeOnElementWithId", &TestRunner::pauseTransitionAtTimeOnElementWithId); + bindMethod("elementDoesAutoCompleteForElementWithId", &TestRunner::elementDoesAutoCompleteForElementWithId); + bindMethod("numberOfActiveAnimations", &TestRunner::numberOfActiveAnimations); + bindMethod("callShouldCloseOnWebView", &TestRunner::callShouldCloseOnWebView); + bindMethod("setDomainRelaxationForbiddenForURLScheme", &TestRunner::setDomainRelaxationForbiddenForURLScheme); + bindMethod("evaluateScriptInIsolatedWorldAndReturnValue", &TestRunner::evaluateScriptInIsolatedWorldAndReturnValue); + bindMethod("evaluateScriptInIsolatedWorld", &TestRunner::evaluateScriptInIsolatedWorld); + bindMethod("setIsolatedWorldSecurityOrigin", &TestRunner::setIsolatedWorldSecurityOrigin); + bindMethod("setIsolatedWorldContentSecurityPolicy", &TestRunner::setIsolatedWorldContentSecurityPolicy); + bindMethod("addOriginAccessWhitelistEntry", &TestRunner::addOriginAccessWhitelistEntry); + bindMethod("removeOriginAccessWhitelistEntry", &TestRunner::removeOriginAccessWhitelistEntry); + bindMethod("hasCustomPageSizeStyle", &TestRunner::hasCustomPageSizeStyle); + bindMethod("forceRedSelectionColors", &TestRunner::forceRedSelectionColors); + bindMethod("addUserScript", &TestRunner::addUserScript); + bindMethod("addUserStyleSheet", &TestRunner::addUserStyleSheet); + bindMethod("startSpeechInput", &TestRunner::startSpeechInput); + bindMethod("loseCompositorContext", &TestRunner::loseCompositorContext); + bindMethod("markerTextForListItem", &TestRunner::markerTextForListItem); + bindMethod("findString", &TestRunner::findString); + bindMethod("setMinimumTimerInterval", &TestRunner::setMinimumTimerInterval); + bindMethod("setAutofilled", &TestRunner::setAutofilled); + bindMethod("setValueForUser", &TestRunner::setValueForUser); + bindMethod("enableFixedLayoutMode", &TestRunner::enableFixedLayoutMode); + bindMethod("setFixedLayoutSize", &TestRunner::setFixedLayoutSize); + bindMethod("selectionAsMarkup", &TestRunner::selectionAsMarkup); + bindMethod("setTextSubpixelPositioning", &TestRunner::setTextSubpixelPositioning); + bindMethod("resetPageVisibility", &TestRunner::resetPageVisibility); + bindMethod("setPageVisibility", &TestRunner::setPageVisibility); + bindMethod("setTextDirection", &TestRunner::setTextDirection); + bindMethod("textSurroundingNode", &TestRunner::textSurroundingNode); + + // Properties. + bindProperty("workerThreadCount", &TestRunner::workerThreadCount); + bindProperty("globalFlag", &m_globalFlag); + bindProperty("platformName", &m_platformName); + + // The following are stubs. + bindMethod("dumpDatabaseCallbacks", &TestRunner::notImplemented); +#if ENABLE(NOTIFICATIONS) + bindMethod("denyWebNotificationPermission", &TestRunner::notImplemented); + bindMethod("removeAllWebNotificationPermissions", &TestRunner::notImplemented); + bindMethod("simulateWebNotificationClick", &TestRunner::notImplemented); +#endif + bindMethod("setIconDatabaseEnabled", &TestRunner::notImplemented); + bindMethod("setScrollbarPolicy", &TestRunner::notImplemented); + bindMethod("clearAllApplicationCaches", &TestRunner::notImplemented); + bindMethod("clearApplicationCacheForOrigin", &TestRunner::notImplemented); + bindMethod("clearBackForwardList", &TestRunner::notImplemented); + bindMethod("keepWebHistory", &TestRunner::notImplemented); + bindMethod("setApplicationCacheOriginQuota", &TestRunner::notImplemented); + bindMethod("setCallCloseOnWebViews", &TestRunner::notImplemented); + bindMethod("setMainFrameIsFirstResponder", &TestRunner::notImplemented); + bindMethod("setPrivateBrowsingEnabled", &TestRunner::notImplemented); + bindMethod("setUseDashboardCompatibilityMode", &TestRunner::notImplemented); + bindMethod("deleteAllLocalStorage", &TestRunner::notImplemented); + bindMethod("localStorageDiskUsageForOrigin", &TestRunner::notImplemented); + bindMethod("originsWithLocalStorage", &TestRunner::notImplemented); + bindMethod("deleteLocalStorageForOrigin", &TestRunner::notImplemented); + bindMethod("observeStorageTrackerNotifications", &TestRunner::notImplemented); + bindMethod("syncLocalStorage", &TestRunner::notImplemented); + bindMethod("addDisallowedURL", &TestRunner::notImplemented); + bindMethod("applicationCacheDiskUsageForOrigin", &TestRunner::notImplemented); + bindMethod("abortModal", &TestRunner::notImplemented); + + // The fallback method is called when an unknown method is invoked. + bindFallbackMethod(&TestRunner::fallbackMethod); +} + +void TestRunner::reset() +{ + if (m_webView) { + m_webView->setZoomLevel(false, 0); + m_webView->setTabKeyCyclesThroughElements(true); +#if !OS(DARWIN) && !OS(WINDOWS) // Actually, TOOLKIT_GTK + // (Constants copied because we can't depend on the header that defined + // them from this file.) + m_webView->setSelectionColors(0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232); +#endif + m_webView->removeAllUserContent(); + m_webView->disableAutoResizeMode(); + } + WebSecurityPolicy::resetOriginAccessWhitelists(); +#if OS(LINUX) || OS(ANDROID) + WebFontRendering::setSubpixelPositioning(false); +#endif + + m_globalFlag.set(false); + m_platformName.set("chromium"); +} + +void TestRunner::setTabKeyCyclesThroughElements(const CppArgumentList& arguments, CppVariant* result) +{ + if (arguments.size() > 0 && arguments[0].isBool()) + m_webView->setTabKeyCyclesThroughElements(arguments[0].toBoolean()); + result->setNull(); +} + +void TestRunner::setAsynchronousSpellCheckingEnabled(const CppArgumentList& arguments, CppVariant* result) +{ + if (arguments.size() > 0 && arguments[0].isBool()) + m_webView->settings()->setAsynchronousSpellCheckingEnabled(cppVariantToBool(arguments[0])); + result->setNull(); +} + +void TestRunner::execCommand(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() <= 0 || !arguments[0].isString()) + return; + + std::string command = arguments[0].toString(); + std::string value(""); + // Ignore the second parameter (which is userInterface) + // since this command emulates a manual action. + if (arguments.size() >= 3 && arguments[2].isString()) + value = arguments[2].toString(); + + // Note: webkit's version does not return the boolean, so neither do we. + m_webView->focusedFrame()->executeCommand(WebString::fromUTF8(command), WebString::fromUTF8(value)); +} + +void TestRunner::isCommandEnabled(const CppArgumentList& arguments, CppVariant* result) +{ + if (arguments.size() <= 0 || !arguments[0].isString()) { + result->setNull(); + return; + } + + std::string command = arguments[0].toString(); + bool rv = m_webView->focusedFrame()->isCommandEnabled(WebString::fromUTF8(command)); + result->set(rv); +} + +bool TestRunner::pauseAnimationAtTimeOnElementWithId(const WebString& animationName, double time, const WebString& elementId) +{ + WebFrame* webFrame = m_webView->mainFrame(); + if (!webFrame) + return false; + + WebAnimationController* controller = webFrame->animationController(); + if (!controller) + return false; + + WebElement element = webFrame->document().getElementById(elementId); + if (element.isNull()) + return false; + return controller->pauseAnimationAtTime(element, animationName, time); +} + +bool TestRunner::pauseTransitionAtTimeOnElementWithId(const WebString& propertyName, double time, const WebString& elementId) +{ + WebFrame* webFrame = m_webView->mainFrame(); + if (!webFrame) + return false; + + WebAnimationController* controller = webFrame->animationController(); + if (!controller) + return false; + + WebElement element = webFrame->document().getElementById(elementId); + if (element.isNull()) + return false; + return controller->pauseTransitionAtTime(element, propertyName, time); +} + +bool TestRunner::elementDoesAutoCompleteForElementWithId(const WebString& elementId) +{ + WebFrame* webFrame = m_webView->mainFrame(); + if (!webFrame) + return false; + + WebElement element = webFrame->document().getElementById(elementId); + if (element.isNull() || !element.hasTagName("input")) + return false; + + WebInputElement inputElement = element.to<WebInputElement>(); + return inputElement.autoComplete(); +} + +int TestRunner::numberOfActiveAnimations() +{ + WebFrame* webFrame = m_webView->mainFrame(); + if (!webFrame) + return -1; + + WebAnimationController* controller = webFrame->animationController(); + if (!controller) + return -1; + + return controller->numberOfActiveAnimations(); +} + +void TestRunner::pauseAnimationAtTimeOnElementWithId(const CppArgumentList& arguments, CppVariant* result) +{ + result->set(false); + if (arguments.size() > 2 && arguments[0].isString() && arguments[1].isNumber() && arguments[2].isString()) { + WebString animationName = cppVariantToWebString(arguments[0]); + double time = arguments[1].toDouble(); + WebString elementId = cppVariantToWebString(arguments[2]); + result->set(pauseAnimationAtTimeOnElementWithId(animationName, time, elementId)); + } +} + +void TestRunner::pauseTransitionAtTimeOnElementWithId(const CppArgumentList& arguments, CppVariant* result) +{ + result->set(false); + if (arguments.size() > 2 && arguments[0].isString() && arguments[1].isNumber() && arguments[2].isString()) { + WebString propertyName = cppVariantToWebString(arguments[0]); + double time = arguments[1].toDouble(); + WebString elementId = cppVariantToWebString(arguments[2]); + result->set(pauseTransitionAtTimeOnElementWithId(propertyName, time, elementId)); + } +} + +void TestRunner::elementDoesAutoCompleteForElementWithId(const CppArgumentList& arguments, CppVariant* result) +{ + if (arguments.size() != 1 || !arguments[0].isString()) { + result->set(false); + return; + } + WebString elementId = cppVariantToWebString(arguments[0]); + result->set(elementDoesAutoCompleteForElementWithId(elementId)); +} + +void TestRunner::numberOfActiveAnimations(const CppArgumentList&, CppVariant* result) +{ + result->set(numberOfActiveAnimations()); +} + +void TestRunner::callShouldCloseOnWebView(const CppArgumentList&, CppVariant* result) +{ + result->set(m_webView->dispatchBeforeUnloadEvent()); +} + +void TestRunner::setDomainRelaxationForbiddenForURLScheme(const CppArgumentList& arguments, CppVariant* result) +{ + if (arguments.size() != 2 || !arguments[0].isBool() || !arguments[1].isString()) + return; + m_webView->setDomainRelaxationForbidden(cppVariantToBool(arguments[0]), cppVariantToWebString(arguments[1])); +} + +void TestRunner::evaluateScriptInIsolatedWorldAndReturnValue(const CppArgumentList& arguments, CppVariant* result) +{ + v8::HandleScope scope; + WebVector<v8::Local<v8::Value> > values; + if (arguments.size() >= 2 && arguments[0].isNumber() && arguments[1].isString()) { + WebScriptSource source(cppVariantToWebString(arguments[1])); + // This relies on the iframe focusing itself when it loads. This is a bit + // sketchy, but it seems to be what other tests do. + m_webView->focusedFrame()->executeScriptInIsolatedWorld(arguments[0].toInt32(), &source, 1, 1, &values); + } + result->setNull(); + // Since only one script was added, only one result is expected + if (values.size() == 1 && !values[0].IsEmpty()) { + v8::Local<v8::Value> scriptValue = values[0]; + // FIXME: There are many more types that can be handled. + if (scriptValue->IsString()) { + v8::String::AsciiValue asciiV8(scriptValue); + result->set(std::string(*asciiV8)); + } else if (scriptValue->IsBoolean()) + result->set(scriptValue->ToBoolean()->Value()); + else if (scriptValue->IsNumber()) { + if (scriptValue->IsInt32()) + result->set(scriptValue->ToInt32()->Value()); + else + result->set(scriptValue->ToNumber()->Value()); + } else if (scriptValue->IsNull()) + result->setNull(); + } +} + +void TestRunner::evaluateScriptInIsolatedWorld(const CppArgumentList& arguments, CppVariant* result) +{ + if (arguments.size() >= 2 && arguments[0].isNumber() && arguments[1].isString()) { + WebScriptSource source(cppVariantToWebString(arguments[1])); + // This relies on the iframe focusing itself when it loads. This is a bit + // sketchy, but it seems to be what other tests do. + m_webView->focusedFrame()->executeScriptInIsolatedWorld(arguments[0].toInt32(), &source, 1, 1); + } + result->setNull(); +} + +void TestRunner::setIsolatedWorldSecurityOrigin(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + + if (arguments.size() != 2 || !arguments[0].isNumber() || !(arguments[1].isString() || arguments[1].isNull())) + return; + + WebSecurityOrigin origin; + if (arguments[1].isString()) + origin = WebSecurityOrigin::createFromString(cppVariantToWebString(arguments[1])); + m_webView->focusedFrame()->setIsolatedWorldSecurityOrigin(arguments[0].toInt32(), origin); +} + +void TestRunner::setIsolatedWorldContentSecurityPolicy(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + + if (arguments.size() != 2 || !arguments[0].isNumber() || !arguments[1].isString()) + return; + + m_webView->focusedFrame()->setIsolatedWorldContentSecurityPolicy(arguments[0].toInt32(), cppVariantToWebString(arguments[1])); +} + +void TestRunner::addOriginAccessWhitelistEntry(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + + if (arguments.size() != 4 || !arguments[0].isString() || !arguments[1].isString() + || !arguments[2].isString() || !arguments[3].isBool()) + return; + + WebKit::WebURL url(GURL(arguments[0].toString())); + if (!url.isValid()) + return; + + WebSecurityPolicy::addOriginAccessWhitelistEntry( + url, + cppVariantToWebString(arguments[1]), + cppVariantToWebString(arguments[2]), + arguments[3].toBoolean()); +} + +void TestRunner::removeOriginAccessWhitelistEntry(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + + if (arguments.size() != 4 || !arguments[0].isString() || !arguments[1].isString() + || !arguments[2].isString() || !arguments[3].isBool()) + return; + + WebKit::WebURL url(GURL(arguments[0].toString())); + if (!url.isValid()) + return; + + WebSecurityPolicy::removeOriginAccessWhitelistEntry( + url, + cppVariantToWebString(arguments[1]), + cppVariantToWebString(arguments[2]), + arguments[3].toBoolean()); +} + +void TestRunner::hasCustomPageSizeStyle(const CppArgumentList& arguments, CppVariant* result) +{ + result->set(false); + int pageIndex = 0; + if (arguments.size() > 1) + return; + if (arguments.size() == 1) + pageIndex = cppVariantToInt32(arguments[0]); + WebFrame* frame = m_webView->mainFrame(); + if (!frame) + return; + result->set(frame->hasCustomPageSizeStyle(pageIndex)); +} + +void TestRunner::forceRedSelectionColors(const CppArgumentList& arguments, CppVariant* result) { + result->setNull(); + m_webView->setSelectionColors(0xffee0000, 0xff00ee00, 0xff000000, 0xffc0c0c0); +} + +void TestRunner::addUserScript(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() < 3 || !arguments[0].isString() || !arguments[1].isBool() || !arguments[2].isBool()) + return; + WebView::addUserScript( + cppVariantToWebString(arguments[0]), WebVector<WebString>(), + arguments[1].toBoolean() ? WebView::UserScriptInjectAtDocumentStart : WebView::UserScriptInjectAtDocumentEnd, + arguments[2].toBoolean() ? WebView::UserContentInjectInAllFrames : WebView::UserContentInjectInTopFrameOnly); +} + +void TestRunner::addUserStyleSheet(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() < 2 || !arguments[0].isString() || !arguments[1].isBool()) + return; + WebView::addUserStyleSheet( + cppVariantToWebString(arguments[0]), WebVector<WebString>(), + arguments[1].toBoolean() ? WebView::UserContentInjectInAllFrames : WebView::UserContentInjectInTopFrameOnly, + // Chromium defaults to InjectInSubsequentDocuments, but for compatibility + // with the other ports' DRTs, we use UserStyleInjectInExistingDocuments. + WebView::UserStyleInjectInExistingDocuments); +} + +void TestRunner::startSpeechInput(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() != 1) + return; + + WebElement element; + if (!WebBindings::getElement(arguments[0].value.objectValue, &element)) + return; + + WebInputElement* input = toWebInputElement(&element); + if (!input) + return; + + if (!input->isSpeechInputEnabled()) + return; + + input->startSpeechInput(); +} + +void TestRunner::loseCompositorContext(const CppArgumentList& args, CppVariant*) +{ + int numTimes; + if (args.size() == 1 || !args[0].isNumber()) + numTimes = 1; + else + numTimes = args[0].toInt32(); + m_webView->loseCompositorContext(numTimes); +} + +void TestRunner::markerTextForListItem(const CppArgumentList& args, CppVariant* result) +{ + WebElement element; + if (!WebBindings::getElement(args[0].value.objectValue, &element)) + result->setNull(); + else + result->set(element.document().frame()->markerTextForListItem(element).utf8()); +} + +void TestRunner::findString(const CppArgumentList& arguments, CppVariant* result) +{ + if (arguments.size() < 1 || !arguments[0].isString()) + return; + + WebFindOptions findOptions; + bool wrapAround = false; + if (arguments.size() >= 2) { + Vector<std::string> optionsArray = arguments[1].toStringVector(); + findOptions.matchCase = true; + + for (size_t i = 0; i < optionsArray.size(); ++i) { + const std::string& option = optionsArray[i]; + // FIXME: Support all the options, so we can run findString.html too. + if (option == "CaseInsensitive") + findOptions.matchCase = false; + else if (option == "Backwards") + findOptions.forward = false; + else if (option == "WrapAround") + wrapAround = true; + } + } + + WebFrame* frame = m_webView->mainFrame(); + const bool findResult = frame->find(0, cppVariantToWebString(arguments[0]), findOptions, wrapAround, 0); + result->set(findResult); +} + +void TestRunner::setMinimumTimerInterval(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() < 1 || !arguments[0].isNumber()) + return; + m_webView->settings()->setMinimumTimerInterval(arguments[0].toDouble()); +} + +void TestRunner::setAutofilled(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() != 2 || !arguments[1].isBool()) + return; + + WebElement element; + if (!WebBindings::getElement(arguments[0].value.objectValue, &element)) + return; + + WebInputElement* input = toWebInputElement(&element); + if (!input) + return; + + input->setAutofilled(arguments[1].value.boolValue); +} + +void TestRunner::setValueForUser(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() != 2) + return; + + WebElement element; + if (!WebBindings::getElement(arguments[0].value.objectValue, &element)) + return; + + WebInputElement* input = toWebInputElement(&element); + if (!input) + return; + + input->setValue(cppVariantToWebString(arguments[1]), true); +} + +void TestRunner::enableFixedLayoutMode(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() < 1 || !arguments[0].isBool()) + return; + bool enableFixedLayout = arguments[0].toBoolean(); + m_webView->enableFixedLayoutMode(enableFixedLayout); +} + +void TestRunner::setFixedLayoutSize(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() < 2 || !arguments[0].isNumber() || !arguments[1].isNumber()) + return; + int width = arguments[0].toInt32(); + int height = arguments[1].toInt32(); + m_webView->setFixedLayoutSize(WebSize(width, height)); +} + +void TestRunner::selectionAsMarkup(const CppArgumentList& arguments, CppVariant* result) +{ + result->set(m_webView->mainFrame()->selectionAsMarkup().utf8()); +} + +void TestRunner::setTextSubpixelPositioning(const CppArgumentList& arguments, CppVariant* result) +{ +#if OS(LINUX) || OS(ANDROID) + // Since FontConfig doesn't provide a variable to control subpixel positioning, we'll fall back + // to setting it globally for all fonts. + if (arguments.size() > 0 && arguments[0].isBool()) + WebFontRendering::setSubpixelPositioning(arguments[0].value.boolValue); +#endif + result->setNull(); +} + +void TestRunner::resetPageVisibility(const CppArgumentList& arguments, CppVariant* result) +{ + m_webView->setVisibilityState(WebPageVisibilityStateVisible, true); +} + +void TestRunner::setPageVisibility(const CppArgumentList& arguments, CppVariant* result) +{ + if (arguments.size() > 0 && arguments[0].isString()) { + string newVisibility = arguments[0].toString(); + if (newVisibility == "visible") + m_webView->setVisibilityState(WebPageVisibilityStateVisible, false); + else if (newVisibility == "hidden") + m_webView->setVisibilityState(WebPageVisibilityStateHidden, false); + else if (newVisibility == "prerender") + m_webView->setVisibilityState(WebPageVisibilityStatePrerender, false); + else if (newVisibility == "preview") + m_webView->setVisibilityState(WebPageVisibilityStatePreview, false); + } +} + +void TestRunner::setTextDirection(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() != 1 || !arguments[0].isString()) + return; + + // Map a direction name to a WebTextDirection value. + std::string directionName = arguments[0].toString(); + WebKit::WebTextDirection direction; + if (directionName == "auto") + direction = WebKit::WebTextDirectionDefault; + else if (directionName == "rtl") + direction = WebKit::WebTextDirectionRightToLeft; + else if (directionName == "ltr") + direction = WebKit::WebTextDirectionLeftToRight; + else + return; + + m_webView->setTextDirection(direction); +} + +void TestRunner::textSurroundingNode(const CppArgumentList& arguments, CppVariant* result) +{ + result->setNull(); + if (arguments.size() < 4 || !arguments[0].isObject() || !arguments[1].isNumber() || !arguments[2].isNumber() || !arguments[3].isNumber()) + return; + + WebNode node; + if (!WebBindings::getNode(arguments[0].value.objectValue, &node)) + return; + + if (node.isNull() || !node.isTextNode()) + return; + + WebPoint point(arguments[1].toInt32(), arguments[2].toInt32()); + unsigned maxLength = arguments[3].toInt32(); + + WebSurroundingText surroundingText; + surroundingText.initialize(node, point, maxLength); + if (surroundingText.isNull()) + return; + + result->set(surroundingText.textContent().utf8()); +} + +void TestRunner::workerThreadCount(CppVariant* result) +{ + result->set(static_cast<int>(WebWorkerInfo::dedicatedWorkerCount())); +} + +// Need these conversions because the format of the value for booleans +// may vary - for example, on mac "1" and "0" are used for boolean. +bool TestRunner::cppVariantToBool(const CppVariant& value) +{ + if (value.isBool()) + return value.toBoolean(); + if (value.isNumber()) + return value.toInt32(); + if (value.isString()) { + string valueString = value.toString(); + if (valueString == "true" || valueString == "1") + return true; + if (valueString == "false" || valueString == "0") + return false; + } + printErrorMessage("Invalid value. Expected boolean value."); + return false; +} + +int32_t TestRunner::cppVariantToInt32(const CppVariant& value) +{ + if (value.isNumber()) + return value.toInt32(); + if (value.isString()) { + string stringSource = value.toString(); + const char* source = stringSource.data(); + char* end; + long number = strtol(source, &end, 10); + if (end == source + stringSource.length() && number >= numeric_limits<int32_t>::min() && number <= numeric_limits<int32_t>::max()) + return static_cast<int32_t>(number); + } + printErrorMessage("Invalid value for preference. Expected integer value."); + return 0; +} + +WebString TestRunner::cppVariantToWebString(const CppVariant& value) +{ + if (!value.isString()) { + printErrorMessage("Invalid value for preference. Expected string value."); + return WebString(); + } + return WebString::fromUTF8(value.toString()); +} + +Vector<WebString> TestRunner::cppVariantToWebStringArray(const CppVariant& value) +{ + if (!value.isObject()) { + printErrorMessage("Invalid value for preference. Expected object value."); + return Vector<WebString>(); + } + Vector<WebString> resultVector; + Vector<string> stringVector = value.toStringVector(); + for (size_t i = 0; i < stringVector.size(); ++i) + resultVector.append(WebString::fromUTF8(stringVector[i].c_str())); + return resultVector; +} + +void TestRunner::printErrorMessage(const string& text) +{ + m_delegate->printMessage(string("CONSOLE MESSAGE: ") + text + "\n"); +} + +void TestRunner::fallbackMethod(const CppArgumentList&, CppVariant* result) +{ + printErrorMessage("JavaScript ERROR: unknown method called on TestRunner"); + result->setNull(); +} + +void TestRunner::notImplemented(const CppArgumentList&, CppVariant* result) +{ + result->setNull(); +} + } diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/TestRunner.h b/Tools/DumpRenderTree/chromium/TestRunner/src/TestRunner.h index 503271b5d..f9e9f7a24 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/TestRunner.h +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/TestRunner.h @@ -34,9 +34,154 @@ #include "CppBoundClass.h" +namespace WebKit { +class WebView; +} + +namespace WebTestRunner { + +class WebTestDelegate; + class TestRunner : public CppBoundClass { public: TestRunner(); + + // FIXME: once DRTTestRunner is moved entirely to this class, change this + // method to take a TestDelegate* instead. + void setDelegate(WebTestDelegate* delegate) { m_delegate = delegate; } + void setWebView(WebKit::WebView* webView) { m_webView = webView; } + + void reset(); + +protected: + // FIXME: make these private once the move from DRTTestRunner to TestRunner + // is complete. + bool cppVariantToBool(const CppVariant&); + int32_t cppVariantToInt32(const CppVariant&); + WebKit::WebString cppVariantToWebString(const CppVariant&); + Vector<WebKit::WebString> cppVariantToWebStringArray(const CppVariant&); + + void printErrorMessage(const std::string&); + +private: + /////////////////////////////////////////////////////////////////////////// + // Methods implemented entirely in terms of chromium's public WebKit API + + // Method that controls whether pressing Tab key cycles through page elements + // or inserts a '\t' char in text area + void setTabKeyCyclesThroughElements(const CppArgumentList&, CppVariant*); + + // Changes asynchronous spellchecking flag on the settings. + void setAsynchronousSpellCheckingEnabled(const CppArgumentList&, CppVariant*); + + // Executes an internal command (superset of document.execCommand() commands). + void execCommand(const CppArgumentList&, CppVariant*); + + // Checks if an internal command is currently available. + void isCommandEnabled(const CppArgumentList&, CppVariant*); + + void pauseAnimationAtTimeOnElementWithId(const CppArgumentList&, CppVariant*); + void pauseTransitionAtTimeOnElementWithId(const CppArgumentList&, CppVariant*); + void elementDoesAutoCompleteForElementWithId(const CppArgumentList&, CppVariant*); + void numberOfActiveAnimations(const CppArgumentList&, CppVariant*); + void callShouldCloseOnWebView(const CppArgumentList&, CppVariant*); + void setDomainRelaxationForbiddenForURLScheme(const CppArgumentList&, CppVariant*); + void evaluateScriptInIsolatedWorldAndReturnValue(const CppArgumentList&, CppVariant*); + void evaluateScriptInIsolatedWorld(const CppArgumentList&, CppVariant*); + void setIsolatedWorldSecurityOrigin(const CppArgumentList&, CppVariant*); + void setIsolatedWorldContentSecurityPolicy(const CppArgumentList&, CppVariant*); + + // Allows layout tests to manage origins' whitelisting. + void addOriginAccessWhitelistEntry(const CppArgumentList&, CppVariant*); + void removeOriginAccessWhitelistEntry(const CppArgumentList&, CppVariant*); + + // Returns true if the current page box has custom page size style for + // printing. + void hasCustomPageSizeStyle(const CppArgumentList&, CppVariant*); + + // Forces the selection colors for testing under Linux. + void forceRedSelectionColors(const CppArgumentList&, CppVariant*); + + // Adds a user script or user style sheet to be injected into new documents. + void addUserScript(const CppArgumentList&, CppVariant*); + void addUserStyleSheet(const CppArgumentList&, CppVariant*); + + void startSpeechInput(const CppArgumentList&, CppVariant*); + + void loseCompositorContext(const CppArgumentList& args, CppVariant* result); + + void markerTextForListItem(const CppArgumentList&, CppVariant*); + void findString(const CppArgumentList&, CppVariant*); + + void setMinimumTimerInterval(const CppArgumentList&, CppVariant*); + + // Expects the first argument to be an input element and the second argument to be a boolean. + // Forwards the setAutofilled() call to the element. + void setAutofilled(const CppArgumentList&, CppVariant*); + + // Expects the first argument to be an input element and the second argument to be a string value. + // Forwards the setValueForUser() call to the element. + void setValueForUser(const CppArgumentList&, CppVariant*); + + void enableFixedLayoutMode(const CppArgumentList&, CppVariant*); + void setFixedLayoutSize(const CppArgumentList&, CppVariant*); + + void selectionAsMarkup(const CppArgumentList&, CppVariant*); + + // Enables or disables subpixel positioning (i.e. fractional X positions for + // glyphs) in text rendering on Linux. Since this method changes global + // settings, tests that call it must use their own custom font family for + // all text that they render. If not, an already-cached style will be used, + // resulting in the changed setting being ignored. + void setTextSubpixelPositioning(const CppArgumentList&, CppVariant*); + + // Switch the visibility of the page. + void setPageVisibility(const CppArgumentList&, CppVariant*); + void resetPageVisibility(const CppArgumentList&, CppVariant*); + + // Changes the direction of the focused element. + void setTextDirection(const CppArgumentList&, CppVariant*); + + // Retrieves the text surrounding a position in a text node. + // Expects the first argument to be a text node, the second and third to be + // point coordinates relative to the node and the fourth the maximum text + // length to retrieve. + void textSurroundingNode(const CppArgumentList&, CppVariant*); + + /////////////////////////////////////////////////////////////////////////// + // Properties + void workerThreadCount(CppVariant*); + + /////////////////////////////////////////////////////////////////////////// + // Fallback and stub methods + + // The fallback method is called when a nonexistent method is called on + // the layout test controller object. + // It is usefull to catch typos in the JavaScript code (a few layout tests + // do have typos in them) and it allows the script to continue running in + // that case (as the Mac does). + void fallbackMethod(const CppArgumentList&, CppVariant*); + + // Stub for not implemented methods. + void notImplemented(const CppArgumentList&, CppVariant*); + + /////////////////////////////////////////////////////////////////////////// + // Internal helpers + bool pauseAnimationAtTimeOnElementWithId(const WebKit::WebString& animationName, double time, const WebKit::WebString& elementId); + bool pauseTransitionAtTimeOnElementWithId(const WebKit::WebString& propertyName, double time, const WebKit::WebString& elementId); + bool elementDoesAutoCompleteForElementWithId(const WebKit::WebString&); + int numberOfActiveAnimations(); + + // globalFlag is used by a number of layout tests in http/tests/security/dataURL. + CppVariant m_globalFlag; + + // Bound variable to return the name of this platform (chromium). + CppVariant m_platformName; + + WebTestDelegate* m_delegate; + WebKit::WebView* m_webView; }; +} + #endif // TestRunner_h diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/TextInputController.cpp b/Tools/DumpRenderTree/chromium/TestRunner/src/TextInputController.cpp index b72a2080d..e929c71fb 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/TextInputController.cpp +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/TextInputController.cpp @@ -44,6 +44,8 @@ using namespace WebKit; +namespace WebTestRunner { + TextInputController::TextInputController() { bindMethod("attributedSubstringFromRange", &TextInputController::attributedSubstringFromRange); @@ -231,3 +233,5 @@ void TextInputController::setComposition(const CppArgumentList& arguments, CppVa WebString text(WebString::fromUTF8(arguments[0].toString())); m_webView->setComposition(text, underlines, 0, text.length()); } + +} diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/TextInputController.h b/Tools/DumpRenderTree/chromium/TestRunner/src/TextInputController.h index a959aa8b3..286d83356 100644 --- a/Tools/DumpRenderTree/chromium/TestRunner/src/TextInputController.h +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/TextInputController.h @@ -41,6 +41,8 @@ namespace WebKit { class WebView; } +namespace WebTestRunner { + class TextInputController : public CppBoundClass { public: TextInputController(); @@ -67,4 +69,6 @@ private: WebKit::WebView* m_webView; }; +} + #endif // TextInputController_h diff --git a/Tools/DumpRenderTree/chromium/TestRunner/src/WebTestProxy.cpp b/Tools/DumpRenderTree/chromium/TestRunner/src/WebTestProxy.cpp new file mode 100644 index 000000000..942f0bb88 --- /dev/null +++ b/Tools/DumpRenderTree/chromium/TestRunner/src/WebTestProxy.cpp @@ -0,0 +1,223 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebTestProxy.h" + +#include "WebAccessibilityController.h" +#include "WebAccessibilityNotification.h" +#include "WebAccessibilityObject.h" +#include "WebElement.h" +#include "WebEventSender.h" +#include "WebNode.h" +#include "WebTestDelegate.h" +#include "WebTestInterfaces.h" +#include "platform/WebCString.h" + +using namespace WebKit; +using namespace std; + +namespace WebTestRunner { + +WebTestProxyBase::WebTestProxyBase() + : m_testInterfaces(0) + , m_delegate(0) +{ +} + +WebTestProxyBase::~WebTestProxyBase() +{ +} + +void WebTestProxyBase::setInterfaces(WebTestInterfaces* interfaces) +{ + m_testInterfaces = interfaces; +} + +void WebTestProxyBase::setDelegate(WebTestDelegate* delegate) +{ + m_delegate = delegate; +} + +void WebTestProxyBase::setPaintRect(const WebRect& rect) +{ + m_paintRect = rect; +} + +WebRect WebTestProxyBase::paintRect() const +{ + return m_paintRect; +} + +void WebTestProxyBase::didInvalidateRect(const WebRect& rect) +{ + // m_paintRect = m_paintRect U rect + if (rect.isEmpty()) + return; + if (m_paintRect.isEmpty()) { + m_paintRect = rect; + return; + } + int left = min(m_paintRect.x, rect.x); + int top = min(m_paintRect.y, rect.y); + int right = max(m_paintRect.x + m_paintRect.width, rect.x + rect.width); + int bottom = max(m_paintRect.y + m_paintRect.height, rect.y + rect.height); + m_paintRect = WebRect(left, top, right - left, bottom - top); +} + +void WebTestProxyBase::didScrollRect(int, int, const WebRect& clipRect) +{ + didInvalidateRect(clipRect); +} + +void WebTestProxyBase::scheduleComposite() +{ + m_paintRect = WebRect(0, 0, INT_MAX, INT_MAX); +} + +void WebTestProxyBase::scheduleAnimation() +{ + scheduleComposite(); +} + +void WebTestProxyBase::show(WebNavigationPolicy) +{ + scheduleComposite(); +} + +void WebTestProxyBase::setWindowRect(const WebRect& rect) +{ + scheduleComposite(); +} + +void WebTestProxyBase::didAutoResize(const WebSize&) +{ + scheduleComposite(); +} + +void WebTestProxyBase::postAccessibilityNotification(const WebKit::WebAccessibilityObject& obj, WebKit::WebAccessibilityNotification notification) +{ + if (notification == WebKit::WebAccessibilityNotificationFocusedUIElementChanged) + m_testInterfaces->accessibilityController()->setFocusedElement(obj); + + const char* notificationName; + switch (notification) { + case WebKit::WebAccessibilityNotificationActiveDescendantChanged: + notificationName = "ActiveDescendantChanged"; + break; + case WebKit::WebAccessibilityNotificationAutocorrectionOccured: + notificationName = "AutocorrectionOccured"; + break; + case WebKit::WebAccessibilityNotificationCheckedStateChanged: + notificationName = "CheckedStateChanged"; + break; + case WebKit::WebAccessibilityNotificationChildrenChanged: + notificationName = "ChildrenChanged"; + break; + case WebKit::WebAccessibilityNotificationFocusedUIElementChanged: + notificationName = "FocusedUIElementChanged"; + break; + case WebKit::WebAccessibilityNotificationLayoutComplete: + notificationName = "LayoutComplete"; + break; + case WebKit::WebAccessibilityNotificationLoadComplete: + notificationName = "LoadComplete"; + break; + case WebKit::WebAccessibilityNotificationSelectedChildrenChanged: + notificationName = "SelectedChildrenChanged"; + break; + case WebKit::WebAccessibilityNotificationSelectedTextChanged: + notificationName = "SelectedTextChanged"; + break; + case WebKit::WebAccessibilityNotificationValueChanged: + notificationName = "ValueChanged"; + break; + case WebKit::WebAccessibilityNotificationScrolledToAnchor: + notificationName = "ScrolledToAnchor"; + break; + case WebKit::WebAccessibilityNotificationLiveRegionChanged: + notificationName = "LiveRegionChanged"; + break; + case WebKit::WebAccessibilityNotificationMenuListItemSelected: + notificationName = "MenuListItemSelected"; + break; + case WebKit::WebAccessibilityNotificationMenuListValueChanged: + notificationName = "MenuListValueChanged"; + break; + case WebKit::WebAccessibilityNotificationRowCountChanged: + notificationName = "RowCountChanged"; + break; + case WebKit::WebAccessibilityNotificationRowCollapsed: + notificationName = "RowCollapsed"; + break; + case WebKit::WebAccessibilityNotificationRowExpanded: + notificationName = "RowExpanded"; + break; + case WebKit::WebAccessibilityNotificationInvalidStatusChanged: + notificationName = "InvalidStatusChanged"; + break; + case WebKit::WebAccessibilityNotificationTextChanged: + notificationName = "TextChanged"; + break; + case WebKit::WebAccessibilityNotificationAriaAttributeChanged: + notificationName = "AriaAttributeChanged"; + break; + default: + notificationName = "UnknownNotification"; + break; + } + + m_testInterfaces->accessibilityController()->notificationReceived(obj, notificationName); + + if (m_testInterfaces->accessibilityController()->shouldLogAccessibilityEvents()) { + std::string message("AccessibilityNotification - "); + message += notificationName; + + WebKit::WebNode node = obj.node(); + if (!node.isNull() && node.isElementNode()) { + WebKit::WebElement element = node.to<WebKit::WebElement>(); + if (element.hasAttribute("id")) { + message += " - id:"; + message += element.getAttribute("id").utf8().data(); + } + } + + m_delegate->printMessage(message + "\n"); + } +} + +void WebTestProxyBase::startDragging(WebFrame*, const WebDragData& data, WebDragOperationsMask mask, const WebImage&, const WebPoint&) +{ + // When running a test, we need to fake a drag drop operation otherwise + // Windows waits for real mouse events to know when the drag is over. + m_testInterfaces->eventSender()->doDragDrop(data, mask); +} + +} diff --git a/Tools/DumpRenderTree/chromium/TestShell.cpp b/Tools/DumpRenderTree/chromium/TestShell.cpp index 2bccb6a32..75fec130a 100644 --- a/Tools/DumpRenderTree/chromium/TestShell.cpp +++ b/Tools/DumpRenderTree/chromium/TestShell.cpp @@ -47,6 +47,7 @@ #include "WebRuntimeFeatures.h" #include "WebScriptController.h" #include "WebSettings.h" +#include "WebTestProxy.h" #include "WebView.h" #include "WebViewHost.h" #include "platform/WebArrayBufferView.h" @@ -117,6 +118,8 @@ TestShell::TestShell() , m_accelerated2dCanvasEnabled(false) , m_deferred2dCanvasEnabled(false) , m_acceleratedPaintingEnabled(false) + , m_perTilePaintingEnabled(false) + , m_acceleratedAnimationEnabled(false) , m_deferredImageDecodingEnabled(false) , m_stressOpt(false) , m_stressDeopt(false) @@ -126,7 +129,6 @@ TestShell::TestShell() WebRuntimeFeatures::enableDataTransferItems(true); WebRuntimeFeatures::enableDeviceMotion(false); WebRuntimeFeatures::enableGeolocation(true); - WebRuntimeFeatures::enablePointerLock(true); WebRuntimeFeatures::enableIndexedDatabase(true); WebRuntimeFeatures::enableInputTypeDateTime(true); WebRuntimeFeatures::enableInputTypeDateTimeLocal(true); @@ -139,7 +141,6 @@ TestShell::TestShell() WebRuntimeFeatures::enableEncryptedMedia(true); WebRuntimeFeatures::enableMediaStream(true); WebRuntimeFeatures::enablePeerConnection(true); - WebRuntimeFeatures::enableDeprecatedPeerConnection(true); WebRuntimeFeatures::enableWebAudio(true); WebRuntimeFeatures::enableVideoTrack(true); WebRuntimeFeatures::enableGamepad(true); @@ -183,6 +184,8 @@ void TestShell::createMainWindow() m_webView = m_webViewHost->webView(); m_testInterfaces->setDelegate(m_webViewHost.get()); m_testInterfaces->setWebView(m_webView); + m_testRunner->setDelegate(m_webViewHost.get()); + m_testRunner->setWebView(m_webView); m_drtDevToolsAgent->setWebView(m_webView); } @@ -190,6 +193,8 @@ TestShell::~TestShell() { m_testInterfaces->setDelegate(0); m_testInterfaces->setWebView(0); + m_testRunner->setDelegate(0); + m_testRunner->setWebView(0); m_drtDevToolsAgent->setWebView(0); } @@ -236,6 +241,8 @@ void TestShell::resetWebSettings(WebView& webView) m_prefs.accelerated2dCanvasEnabled = m_accelerated2dCanvasEnabled; m_prefs.deferred2dCanvasEnabled = m_deferred2dCanvasEnabled; m_prefs.acceleratedPaintingEnabled = m_acceleratedPaintingEnabled; + m_prefs.perTilePaintingEnabled = m_perTilePaintingEnabled; + m_prefs.acceleratedAnimationEnabled = m_acceleratedAnimationEnabled; m_prefs.deferredImageDecodingEnabled = m_deferredImageDecodingEnabled; m_prefs.applyTo(&webView); } @@ -388,16 +395,6 @@ void TestShell::testTimedOut() testFinished(); } -void TestShell::setPerTilePaintingEnabled(bool enabled) -{ - Platform::current()->compositorSupport()->setPerTilePaintingEnabled(enabled); -} - -void TestShell::setAcceleratedAnimationEnabled(bool enabled) -{ - Platform::current()->compositorSupport()->setAcceleratedAnimationEnabled(enabled); -} - static string dumpDocumentText(WebFrame* frame) { // We use the document element's text instead of the body text here because @@ -751,7 +748,13 @@ WebViewHost* TestShell::createNewWindow(const WebKit::WebURL& url) WebViewHost* TestShell::createNewWindow(const WebKit::WebURL& url, DRTDevToolsAgent* devToolsAgent) { - WebViewHost* host = new WebViewHost(this); + WebTestRunner::WebTestProxy<WebViewHost, TestShell*>* host = new WebTestRunner::WebTestProxy<WebViewHost, TestShell*>(this); + host->setInterfaces(m_testInterfaces.get()); + if (m_webViewHost) + host->setDelegate(m_webViewHost.get()); + else + host->setDelegate(host); + host->setProxy(host); WebView* view = WebView::create(host); view->setPermissionClient(webPermissions()); view->setDevToolsAgentClient(devToolsAgent); diff --git a/Tools/DumpRenderTree/chromium/TestShell.h b/Tools/DumpRenderTree/chromium/TestShell.h index 12e1dbbef..9120121db 100644 --- a/Tools/DumpRenderTree/chromium/TestShell.h +++ b/Tools/DumpRenderTree/chromium/TestShell.h @@ -136,8 +136,8 @@ public: void setAccelerated2dCanvasEnabled(bool enabled) { m_accelerated2dCanvasEnabled = enabled; } void setDeferred2dCanvasEnabled(bool enabled) { m_deferred2dCanvasEnabled = enabled; } void setAcceleratedPaintingEnabled(bool enabled) { m_acceleratedPaintingEnabled = enabled; } - void setPerTilePaintingEnabled(bool); - void setAcceleratedAnimationEnabled(bool); + void setPerTilePaintingEnabled(bool enabled) { m_perTilePaintingEnabled = enabled; } + void setAcceleratedAnimationEnabled(bool enabled) { m_acceleratedAnimationEnabled = enabled; } void setDeferredImageDecodingEnabled(bool enabled) { m_deferredImageDecodingEnabled = enabled; } #if defined(OS_WIN) // Access to the finished event. Used by the static WatchDog thread. @@ -218,8 +218,9 @@ private: #if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS) OwnPtr<NotificationPresenter> m_notificationPresenter; #endif - OwnPtr<WebViewHost> m_webViewHost; + // It's important that this thread is destroyed after the WebViewHost. OwnPtr<WebKit::WebThread> m_webCompositorThread; + OwnPtr<WebViewHost> m_webViewHost; #if ENABLE(LINK_PRERENDER) OwnPtr<MockWebPrerenderingSupport> m_prerenderingSupport; #endif @@ -237,6 +238,7 @@ private: bool m_deferred2dCanvasEnabled; bool m_acceleratedPaintingEnabled; bool m_perTilePaintingEnabled; + bool m_acceleratedAnimationEnabled; bool m_deferredImageDecodingEnabled; WebPreferences m_prefs; bool m_stressOpt; diff --git a/Tools/DumpRenderTree/chromium/TestWebPlugin.cpp b/Tools/DumpRenderTree/chromium/TestWebPlugin.cpp index 146884613..2960dc0bd 100644 --- a/Tools/DumpRenderTree/chromium/TestWebPlugin.cpp +++ b/Tools/DumpRenderTree/chromium/TestWebPlugin.cpp @@ -184,6 +184,7 @@ bool TestWebPlugin::initialize(WebPluginContainer* container) m_container = container; m_container->setBackingTextureId(m_colorTexture); m_container->setIsAcceptingTouchEvents(m_acceptsTouchEvent); + m_container->setWantsWheelEvents(true); return true; } diff --git a/Tools/DumpRenderTree/chromium/WebPreferences.cpp b/Tools/DumpRenderTree/chromium/WebPreferences.cpp index 46afbbdb2..e13939d32 100644 --- a/Tools/DumpRenderTree/chromium/WebPreferences.cpp +++ b/Tools/DumpRenderTree/chromium/WebPreferences.cpp @@ -118,6 +118,8 @@ void WebPreferences::reset() deferred2dCanvasEnabled = false; acceleratedPaintingEnabled = false; forceCompositingMode = false; + perTilePaintingEnabled = false; + acceleratedAnimationEnabled = false; deferredImageDecodingEnabled = false; mediaPlaybackRequiresUserGesture = false; mockScrollbarsEnabled = false; @@ -231,10 +233,11 @@ void WebPreferences::applyTo(WebView* webView) settings->setAccelerated2dCanvasEnabled(accelerated2dCanvasEnabled); settings->setDeferred2dCanvasEnabled(deferred2dCanvasEnabled); settings->setAcceleratedPaintingEnabled(acceleratedPaintingEnabled); + settings->setPerTilePaintingEnabled(perTilePaintingEnabled); + settings->setAcceleratedAnimationEnabled(acceleratedAnimationEnabled); settings->setDeferredImageDecodingEnabled(deferredImageDecodingEnabled); settings->setMediaPlaybackRequiresUserGesture(mediaPlaybackRequiresUserGesture); settings->setMockScrollbarsEnabled(mockScrollbarsEnabled); - settings->setApplyDefaultDeviceScaleFactorInCompositor(forceCompositingMode); settings->setShouldRespectImageOrientation(shouldRespectImageOrientation); // Fixed values. @@ -254,4 +257,5 @@ void WebPreferences::applyTo(WebView* webView) settings->setValidationMessageTimerMagnification(-1); settings->setVisualWordMovementEnabled(false); settings->setPasswordEchoEnabled(false); + settings->setApplyDeviceScaleFactorInCompositor(true); } diff --git a/Tools/DumpRenderTree/chromium/WebPreferences.h b/Tools/DumpRenderTree/chromium/WebPreferences.h index 36fcd196f..a17a3cbd2 100644 --- a/Tools/DumpRenderTree/chromium/WebPreferences.h +++ b/Tools/DumpRenderTree/chromium/WebPreferences.h @@ -111,6 +111,8 @@ struct WebPreferences { bool accelerated2dCanvasEnabled; bool deferred2dCanvasEnabled; bool acceleratedPaintingEnabled; + bool perTilePaintingEnabled; + bool acceleratedAnimationEnabled; bool deferredImageDecodingEnabled; bool mediaPlaybackRequiresUserGesture; bool mockScrollbarsEnabled; diff --git a/Tools/DumpRenderTree/chromium/WebViewHost.cpp b/Tools/DumpRenderTree/chromium/WebViewHost.cpp index 98b87bf8e..baf8d0d9e 100644 --- a/Tools/DumpRenderTree/chromium/WebViewHost.cpp +++ b/Tools/DumpRenderTree/chromium/WebViewHost.cpp @@ -39,8 +39,6 @@ #include "TestNavigationController.h" #include "TestShell.h" #include "TestWebPlugin.h" -#include "WebAccessibilityController.h" -#include "WebAccessibilityObject.h" #include "WebConsoleMessage.h" #include "WebContextMenuData.h" #include "WebDOMMessageEvent.h" @@ -148,16 +146,6 @@ static string descriptionSuitableForTestResult(const string& url) return url.substr(pos + 1); } -// Adds a file called "DRTFakeFile" to dragData (CF_HDROP). Use to fake -// dragging a file. -static void addDRTFakeFileToDataObject(WebDragData* dragData) -{ - WebDragData::Item item; - item.storageType = WebDragData::Item::StorageTypeFilename; - item.filenameData = WebString::fromUTF8("DRTFakeFile"); - dragData->addItem(item); -} - // Get a debugging string from a WebNavigationType. static const char* webNavigationTypeToString(WebNavigationType type) { @@ -345,7 +333,7 @@ bool WebViewHost::shouldBeginEditing(const WebRange& range) printRangeDescription(range); fputs("\n", stdout); } - return testRunner()->acceptsEditing(); + return true; } bool WebViewHost::shouldEndEditing(const WebRange& range) @@ -355,7 +343,7 @@ bool WebViewHost::shouldEndEditing(const WebRange& range) printRangeDescription(range); fputs("\n", stdout); } - return testRunner()->acceptsEditing(); + return true; } bool WebViewHost::shouldInsertNode(const WebNode& node, const WebRange& range, WebEditingAction action) @@ -367,7 +355,7 @@ bool WebViewHost::shouldInsertNode(const WebNode& node, const WebRange& range, W printRangeDescription(range); printf(" givenAction:%s\n", editingActionDescription(action).c_str()); } - return testRunner()->acceptsEditing(); + return true; } bool WebViewHost::shouldInsertText(const WebString& text, const WebRange& range, WebEditingAction action) @@ -377,7 +365,7 @@ bool WebViewHost::shouldInsertText(const WebString& text, const WebRange& range, printRangeDescription(range); printf(" givenAction:%s\n", editingActionDescription(action).c_str()); } - return testRunner()->acceptsEditing(); + return true; } bool WebViewHost::shouldChangeSelectedRange( @@ -392,7 +380,7 @@ bool WebViewHost::shouldChangeSelectedRange( textAffinityDescription(affinity).c_str(), (stillSelecting ? "TRUE" : "FALSE")); } - return testRunner()->acceptsEditing(); + return true; } bool WebViewHost::shouldDeleteRange(const WebRange& range) @@ -402,7 +390,7 @@ bool WebViewHost::shouldDeleteRange(const WebRange& range) printRangeDescription(range); fputs("\n", stdout); } - return testRunner()->acceptsEditing(); + return true; } bool WebViewHost::shouldApplyStyle(const WebString& style, const WebRange& range) @@ -412,7 +400,7 @@ bool WebViewHost::shouldApplyStyle(const WebString& style, const WebRange& range printRangeDescription(range); fputs("\n", stdout); } - return testRunner()->acceptsEditing(); + return true; } bool WebViewHost::isSmartInsertDeleteEnabled() @@ -589,19 +577,6 @@ void WebViewHost::setStatusText(const WebString& text) printf("UI DELEGATE STATUS CALLBACK: setStatusText:%s\n", text.utf8().data()); } -void WebViewHost::startDragging(WebFrame*, const WebDragData& data, WebDragOperationsMask mask, const WebImage&, const WebPoint&) -{ - WebDragData mutableDragData = data; - if (testRunner()->shouldAddFileToPasteboard()) { - // Add a file called DRTFakeFile to the drag&drop clipboard. - addDRTFakeFileToDataObject(&mutableDragData); - } - - // When running a test, we need to fake a drag drop operation otherwise - // Windows waits for real mouse events to know when the drag is over. - m_shell->eventSender()->doDragDrop(mutableDragData, mask); -} - void WebViewHost::didUpdateLayout() { #if OS(MAC_OS_X) @@ -635,94 +610,6 @@ int WebViewHost::historyForwardListCount() return navigationController()->entryCount() - currentIndex - 1; } -void WebViewHost::postAccessibilityNotification(const WebAccessibilityObject& obj, WebAccessibilityNotification notification) -{ - if (notification == WebAccessibilityNotificationFocusedUIElementChanged) - m_shell->accessibilityController()->setFocusedElement(obj); - - const char* notificationName; - switch (notification) { - case WebAccessibilityNotificationActiveDescendantChanged: - notificationName = "ActiveDescendantChanged"; - break; - case WebAccessibilityNotificationAutocorrectionOccured: - notificationName = "AutocorrectionOccured"; - break; - case WebAccessibilityNotificationCheckedStateChanged: - notificationName = "CheckedStateChanged"; - break; - case WebAccessibilityNotificationChildrenChanged: - notificationName = "ChildrenChanged"; - break; - case WebAccessibilityNotificationFocusedUIElementChanged: - notificationName = "FocusedUIElementChanged"; - break; - case WebAccessibilityNotificationLayoutComplete: - notificationName = "LayoutComplete"; - break; - case WebAccessibilityNotificationLoadComplete: - notificationName = "LoadComplete"; - break; - case WebAccessibilityNotificationSelectedChildrenChanged: - notificationName = "SelectedChildrenChanged"; - break; - case WebAccessibilityNotificationSelectedTextChanged: - notificationName = "SelectedTextChanged"; - break; - case WebAccessibilityNotificationValueChanged: - notificationName = "ValueChanged"; - break; - case WebAccessibilityNotificationScrolledToAnchor: - notificationName = "ScrolledToAnchor"; - break; - case WebAccessibilityNotificationLiveRegionChanged: - notificationName = "LiveRegionChanged"; - break; - case WebAccessibilityNotificationMenuListItemSelected: - notificationName = "MenuListItemSelected"; - break; - case WebAccessibilityNotificationMenuListValueChanged: - notificationName = "MenuListValueChanged"; - break; - case WebAccessibilityNotificationRowCountChanged: - notificationName = "RowCountChanged"; - break; - case WebAccessibilityNotificationRowCollapsed: - notificationName = "RowCollapsed"; - break; - case WebAccessibilityNotificationRowExpanded: - notificationName = "RowExpanded"; - break; - case WebAccessibilityNotificationInvalidStatusChanged: - notificationName = "InvalidStatusChanged"; - break; - case WebAccessibilityNotificationTextChanged: - notificationName = "TextChanged"; - break; - case WebAccessibilityNotificationAriaAttributeChanged: - notificationName = "AriaAttributeChanged"; - break; - default: - notificationName = "UnknownNotification"; - break; - } - - m_shell->accessibilityController()->notificationReceived(obj, notificationName); - - if (m_shell->accessibilityController()->shouldLogAccessibilityEvents()) { - printf("AccessibilityNotification - %s", notificationName); - - WebKit::WebNode node = obj.node(); - if (!node.isNull() && node.isElementNode()) { - WebKit::WebElement element = node.to<WebKit::WebElement>(); - if (element.hasAttribute("id")) - printf(" - id:%s", element.getAttribute("id").utf8().data()); - } - - printf("\n"); - } -} - #if ENABLE(NOTIFICATIONS) WebNotificationPresenter* WebViewHost::notificationPresenter() { @@ -793,18 +680,6 @@ WebUserMediaClientMock* WebViewHost::userMediaClientMock() // WebWidgetClient ----------------------------------------------------------- -void WebViewHost::didInvalidateRect(const WebRect& rect) -{ - updatePaintRect(rect); -} - -void WebViewHost::didScrollRect(int, int, const WebRect& clipRect) -{ - // This is used for optimizing painting when the renderer is scrolled. We're - // currently not doing any optimizations so just invalidate the region. - didInvalidateRect(clipRect); -} - void WebViewHost::didAutoResize(const WebSize& newSize) { // Purposely don't include the virtualWindowBorder in this case so that @@ -812,27 +687,12 @@ void WebViewHost::didAutoResize(const WebSize& newSize) setWindowRect(WebRect(0, 0, newSize.width, newSize.height)); } -void WebViewHost::scheduleComposite() -{ - WebSize widgetSize = webWidget()->size(); - WebRect clientRect(0, 0, widgetSize.width, widgetSize.height); - didInvalidateRect(clientRect); -} - -#if ENABLE(REQUEST_ANIMATION_FRAME) -void WebViewHost::serviceAnimation() +void WebViewHost::scheduleAnimation() { if (webView()->settings()->scrollAnimatorEnabled()) webView()->animate(0.0); - scheduleComposite(); } -void WebViewHost::scheduleAnimation() -{ - postDelayedTask(new HostMethodTask(this, &WebViewHost::serviceAnimation), 0); -} -#endif - void WebViewHost::didFocus() { m_shell->setFocus(webWidget(), true); @@ -918,8 +778,6 @@ void WebViewHost::didLosePointerLock() void WebViewHost::show(WebNavigationPolicy) { m_hasWindow = true; - WebSize size = webWidget()->size(); - updatePaintRect(WebRect(0, 0, size.width, size.height)); } @@ -960,7 +818,6 @@ void WebViewHost::setWindowRect(const WebRect& rect) int height = m_windowRect.height - border2; discardBackingStore(); webWidget()->resize(WebSize(width, height)); - updatePaintRect(WebRect(0, 0, width, height)); } WebRect WebViewHost::rootWindowRect() @@ -1520,6 +1377,7 @@ WebKit::WebString WebViewHost::getAbsoluteWebStringFromUTF8Path(const std::strin WebViewHost::WebViewHost(TestShell* shell) : m_shell(shell) + , m_proxy(0) , m_webWidget(0) , m_lastRequestedTextCheckingCompletion(0) { @@ -1566,6 +1424,19 @@ WebWidget* WebViewHost::webWidget() const return m_webWidget; } +WebTestProxyBase* WebViewHost::proxy() const +{ + ASSERT(m_proxy); + return m_proxy; +} + +void WebViewHost::setProxy(WebTestProxyBase* proxy) +{ + ASSERT(!m_proxy); + ASSERT(proxy); + m_proxy = proxy; +} + void WebViewHost::reset() { m_policyDelegateEnabled = false; @@ -1610,7 +1481,9 @@ void WebViewHost::reset() m_currentCursor = WebCursorInfo(); m_windowRect = WebRect(); - m_paintRect = WebRect(); + // m_proxy is not set when reset() is invoked from the constructor. + if (m_proxy) + proxy()->setPaintRect(WebRect()); if (m_webWidget) { webView()->mainFrame()->setName(WebString()); @@ -1847,18 +1720,12 @@ void WebViewHost::setAddressBarURL(const WebURL&) void WebViewHost::enterFullScreenNow() { - if (testRunner()->hasCustomFullScreenBehavior()) - return; - webView()->willEnterFullScreen(); webView()->didEnterFullScreen(); } void WebViewHost::exitFullScreenNow() { - if (testRunner()->hasCustomFullScreenBehavior()) - return; - webView()->willExitFullScreen(); webView()->didExitFullScreen(); } @@ -1874,22 +1741,6 @@ webkit_support::TestMediaStreamClient* WebViewHost::testMediaStreamClient() // Painting functions --------------------------------------------------------- -void WebViewHost::updatePaintRect(const WebRect& rect) -{ - // m_paintRect = m_paintRect U rect - if (rect.isEmpty()) - return; - if (m_paintRect.isEmpty()) { - m_paintRect = rect; - return; - } - int left = min(m_paintRect.x, rect.x); - int top = min(m_paintRect.y, rect.y); - int right = max(m_paintRect.x + m_paintRect.width, rect.x + rect.width); - int bottom = max(m_paintRect.y + m_paintRect.height, rect.y + rect.height); - m_paintRect = WebRect(left, top, right - left, bottom - top); -} - void WebViewHost::paintRect(const WebRect& rect) { ASSERT(!m_isPainting); @@ -1920,23 +1771,22 @@ void WebViewHost::paintInvalidatedRegion() // Store the total area painted in total_paint. Then tell the gdk window // to update that area after we're done painting it. for (int i = 0; i < 3; ++i) { - // m_paintRect = intersect(m_paintRect , clientRect) - int left = max(m_paintRect.x, clientRect.x); - int top = max(m_paintRect.y, clientRect.y); - int right = min(m_paintRect.x + m_paintRect.width, clientRect.x + clientRect.width); - int bottom = min(m_paintRect.y + m_paintRect.height, clientRect.y + clientRect.height); - if (left >= right || top >= bottom) - m_paintRect = WebRect(); - else - m_paintRect = WebRect(left, top, right - left, bottom - top); - - if (m_paintRect.isEmpty()) + // rect = intersect(proxy()->paintRect() , clientRect) + WebRect damageRect = proxy()->paintRect(); + int left = max(damageRect.x, clientRect.x); + int top = max(damageRect.y, clientRect.y); + int right = min(damageRect.x + damageRect.width, clientRect.x + clientRect.width); + int bottom = min(damageRect.y + damageRect.height, clientRect.y + clientRect.height); + WebRect rect; + if (left < right && top < bottom) + rect = WebRect(left, top, right - left, bottom - top); + + proxy()->setPaintRect(WebRect()); + if (rect.isEmpty()) continue; - WebRect rect(m_paintRect); - m_paintRect = WebRect(); paintRect(rect); } - ASSERT(m_paintRect.isEmpty()); + ASSERT(proxy()->paintRect().isEmpty()); } void WebViewHost::paintPagesWithBoundaries() diff --git a/Tools/DumpRenderTree/chromium/WebViewHost.h b/Tools/DumpRenderTree/chromium/WebViewHost.h index 86007194b..eb41d54a4 100644 --- a/Tools/DumpRenderTree/chromium/WebViewHost.h +++ b/Tools/DumpRenderTree/chromium/WebViewHost.h @@ -41,6 +41,7 @@ #include "WebSpellCheckClient.h" #include "WebTask.h" #include "WebTestDelegate.h" +#include "WebTestProxy.h" #include "WebViewClient.h" #include <wtf/HashMap.h> #include <wtf/HashSet.h> @@ -86,6 +87,8 @@ class WebViewHost : public WebKit::WebViewClient, public WebKit::WebFrameClient, void setWebWidget(WebKit::WebWidget*); WebKit::WebView* webView() const; WebKit::WebWidget* webWidget() const; + WebTestRunner::WebTestProxyBase* proxy() const; + void setProxy(WebTestRunner::WebTestProxyBase*); void reset(); void setSelectTrailingWhitespaceEnabled(bool); void setSmartInsertDeleteEnabled(bool); @@ -99,7 +102,6 @@ class WebViewHost : public WebKit::WebViewClient, public WebKit::WebFrameClient, void setDeviceScaleFactor(float); void paintRect(const WebKit::WebRect&); - void updatePaintRect(const WebKit::WebRect&); void paintInvalidatedRegion(); void paintPagesWithBoundaries(); SkCanvas* canvas(); @@ -183,12 +185,10 @@ class WebViewHost : public WebKit::WebViewClient, public WebKit::WebFrameClient, virtual bool runModalBeforeUnloadDialog(WebKit::WebFrame*, const WebKit::WebString&); virtual void showContextMenu(WebKit::WebFrame*, const WebKit::WebContextMenuData&); virtual void setStatusText(const WebKit::WebString&); - virtual void startDragging(WebKit::WebFrame*, const WebKit::WebDragData&, WebKit::WebDragOperationsMask, const WebKit::WebImage&, const WebKit::WebPoint&); virtual void didUpdateLayout(); virtual void navigateBackForwardSoon(int offset); virtual int historyBackListCount(); virtual int historyForwardListCount(); - virtual void postAccessibilityNotification(const WebKit::WebAccessibilityObject&, WebKit::WebAccessibilityNotification); #if ENABLE(NOTIFICATIONS) virtual WebKit::WebNotificationPresenter* notificationPresenter(); #endif @@ -206,14 +206,8 @@ class WebViewHost : public WebKit::WebViewClient, public WebKit::WebFrameClient, virtual void printPage(WebKit::WebFrame*); // WebKit::WebWidgetClient - virtual void didInvalidateRect(const WebKit::WebRect&); - virtual void didScrollRect(int dx, int dy, const WebKit::WebRect&); virtual void didAutoResize(const WebKit::WebSize& newSize); - virtual void scheduleComposite(); -#if ENABLE(REQUEST_ANIMATION_FRAME) - virtual void serviceAnimation(); virtual void scheduleAnimation(); -#endif virtual void didFocus(); virtual void didBlur(); virtual void didChangeCursor(const WebKit::WebCursorInfo&); @@ -370,6 +364,9 @@ private: // Non-owning pointer. The WebViewHost instance is owned by this TestShell instance. TestShell* m_shell; + // Non-owning pointer. This class needs to be wrapped in a WebTestProxy. This is the pointer to the WebTestProxyBase. + WebTestRunner::WebTestProxyBase* m_proxy; + // This delegate works for the following widget. WebKit::WebWidget* m_webWidget; diff --git a/Tools/DumpRenderTree/efl/DumpRenderTree.cpp b/Tools/DumpRenderTree/efl/DumpRenderTree.cpp index 3d1c112e0..ef210e07e 100644 --- a/Tools/DumpRenderTree/efl/DumpRenderTree.cpp +++ b/Tools/DumpRenderTree/efl/DumpRenderTree.cpp @@ -384,6 +384,7 @@ static void shutdownEfl() void displayWebView() { + DumpRenderTreeSupportEfl::forceLayout(browser->mainFrame()); DumpRenderTreeSupportEfl::setTracksRepaints(browser->mainFrame(), true); DumpRenderTreeSupportEfl::resetTrackedRepaints(browser->mainFrame()); } diff --git a/Tools/DumpRenderTree/efl/EventSender.cpp b/Tools/DumpRenderTree/efl/EventSender.cpp index e2ff5e1f6..92b788991 100644 --- a/Tools/DumpRenderTree/efl/EventSender.cpp +++ b/Tools/DumpRenderTree/efl/EventSender.cpp @@ -992,7 +992,6 @@ static void feedMouseEvent(MouseEventInfo* eventInfo) unsigned timeStamp = 0; Evas_Object* mainFrame = browser->mainFrame(); Evas* evas = evas_object_evas_get(mainFrame); - DumpRenderTreeSupportEfl::layoutFrame(mainFrame); EvasMouseEvent event = eventInfo->event; setEvasModifiers(evas, eventInfo->modifiers); diff --git a/Tools/DumpRenderTree/efl/PixelDumpSupportEfl.cpp b/Tools/DumpRenderTree/efl/PixelDumpSupportEfl.cpp index 446483652..241903988 100644 --- a/Tools/DumpRenderTree/efl/PixelDumpSupportEfl.cpp +++ b/Tools/DumpRenderTree/efl/PixelDumpSupportEfl.cpp @@ -38,7 +38,7 @@ #include "PixelDumpSupportCairo.h" #include "RefPtrCairo.h" #include "WebCoreSupport/DumpRenderTreeSupportEfl.h" -#include "ewk_view_private.h" +#include "ewk_view.h" PassRefPtr<BitmapContext> createBitmapContextFromWebView(bool, bool, bool, bool drawSelectionRect) { diff --git a/Tools/DumpRenderTree/mac/DumpRenderTree.mm b/Tools/DumpRenderTree/mac/DumpRenderTree.mm index 3cd121488..908a231b9 100644 --- a/Tools/DumpRenderTree/mac/DumpRenderTree.mm +++ b/Tools/DumpRenderTree/mac/DumpRenderTree.mm @@ -693,6 +693,9 @@ static void resetDefaultsToConsistentValues() // Called once on DumpRenderTree startup. static void setDefaultsToConsistentValuesForTesting() { + // FIXME: We'd like to start with a clean state for every test, but this function can't be used more than once yet. + [WebPreferences _switchNetworkLoaderToNewTestingSession]; + resetDefaultsToConsistentValues(); NSString *path = libraryPathForDumpRenderTree(); @@ -702,8 +705,6 @@ static void setDefaultsToConsistentValuesForTesting() diskPath:[path stringByAppendingPathComponent:@"URLCache"]]; [NSURLCache setSharedURLCache:sharedCache]; [sharedCache release]; - - [WebPreferences _switchNetworkLoaderToNewTestingSession]; } static void runThread(void* arg) diff --git a/Tools/DumpRenderTree/win/EventSender.cpp b/Tools/DumpRenderTree/win/EventSender.cpp index 76dafd948..5cc73c0b8 100644 --- a/Tools/DumpRenderTree/win/EventSender.cpp +++ b/Tools/DumpRenderTree/win/EventSender.cpp @@ -45,6 +45,9 @@ #include <wtf/text/WTFString.h> #define WM_DRT_SEND_QUEUED_EVENT (WM_APP+1) +#ifndef MAPVK_VK_TO_VSC +#define MAPVK_VK_TO_VSC 0 +#endif static bool down; static bool dragMode = true; @@ -434,6 +437,16 @@ void replaySavedEvents(HRESULT* oleDragAndDropReturnValue) replayingSavedEvents = false; } +static int makeKeyDataForScanCode(int virtualKeyCode) +{ + unsigned scancode = MapVirtualKey(virtualKeyCode, MAPVK_VK_TO_VSC); + int keyData = scancode & 0xFF; + scancode = scancode >> 8; + if (scancode == 0xe0 || scancode == 0xe1) + keyData += KF_EXTENDED; + return keyData << 16; +} + static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { if (argumentCount < 1) @@ -479,19 +492,25 @@ static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JS virtualKeyCode = VK_SNAPSHOT; else if (JSStringIsEqualToUTF8CString(character, "menu")) virtualKeyCode = VK_APPS; - else if (JSStringIsEqualToUTF8CString(character, "leftControl")) - virtualKeyCode = VK_LCONTROL; - else if (JSStringIsEqualToUTF8CString(character, "leftShift")) - virtualKeyCode = VK_LSHIFT; - else if (JSStringIsEqualToUTF8CString(character, "leftAlt")) - virtualKeyCode = VK_LMENU; - else if (JSStringIsEqualToUTF8CString(character, "rightControl")) - virtualKeyCode = VK_RCONTROL; - else if (JSStringIsEqualToUTF8CString(character, "rightShift")) - virtualKeyCode = VK_RSHIFT; - else if (JSStringIsEqualToUTF8CString(character, "rightAlt")) - virtualKeyCode = VK_RMENU; - else { + else if (JSStringIsEqualToUTF8CString(character, "leftControl")) { + virtualKeyCode = VK_CONTROL; + keyData += makeKeyDataForScanCode(VK_LCONTROL); + } else if (JSStringIsEqualToUTF8CString(character, "leftShift")) { + virtualKeyCode = VK_SHIFT; + keyData += makeKeyDataForScanCode(VK_LSHIFT); + } else if (JSStringIsEqualToUTF8CString(character, "leftAlt")) { + virtualKeyCode = VK_MENU; + keyData += makeKeyDataForScanCode(VK_LMENU); + } else if (JSStringIsEqualToUTF8CString(character, "rightControl")) { + virtualKeyCode = VK_CONTROL; + keyData += makeKeyDataForScanCode(VK_RCONTROL); + } else if (JSStringIsEqualToUTF8CString(character, "rightShift")) { + virtualKeyCode = VK_SHIFT; + keyData += makeKeyDataForScanCode(VK_RSHIFT); + } else if (JSStringIsEqualToUTF8CString(character, "rightAlt")) { + virtualKeyCode = VK_MENU; + keyData += makeKeyDataForScanCode(VK_RMENU); + } else { charCode = JSStringGetCharactersPtr(character)[0]; virtualKeyCode = LOBYTE(VkKeyScan(charCode)); if (WTF::isASCIIUpper(charCode)) diff --git a/Tools/EWebLauncher/main.c b/Tools/EWebLauncher/main.c index b1192435f..684800a1c 100644 --- a/Tools/EWebLauncher/main.c +++ b/Tools/EWebLauncher/main.c @@ -126,6 +126,8 @@ static const Ecore_Getopt options = { ecore_getopt_callback_geometry_parse, NULL), ECORE_GETOPT_STORE_STR ('t', "theme", "path to read the theme file from."), + ECORE_GETOPT_STORE_DEF_BOOL + ('T', "tiled-backing-store", "enable/disable WebCore's tiled backingstore(ewk_view_single only)", 0), ECORE_GETOPT_STORE_STR ('U', "user-agent", "custom user agent string to use."), ECORE_GETOPT_COUNT @@ -147,6 +149,7 @@ typedef struct _User_Arguments { Eina_Bool quitOption; char *backingStore; Eina_Bool enableEncodingDetector; + Eina_Bool enableTiledBackingStore; Eina_Bool isFlattening; Eina_Bool isFullscreen; Eina_Rectangle geometry; @@ -847,6 +850,8 @@ windowCreate(User_Arguments *userArgs) } else { app->browser = ewk_view_single_add(app->evas); info("backing store: single\n"); + + ewk_view_setting_tiled_backing_store_enabled_set(app->browser, userArgs->enableTiledBackingStore); } ewk_view_theme_set(app->browser, themePath); @@ -932,6 +937,7 @@ parseUserArguments(int argc, char *argv[], User_Arguments *userArgs) userArgs->quitOption = EINA_FALSE; userArgs->backingStore = (char *)backingStores[1]; userArgs->enableEncodingDetector = EINA_FALSE; + userArgs->enableTiledBackingStore = EINA_FALSE; userArgs->isFlattening = EINA_FALSE; userArgs->isFullscreen = EINA_FALSE; userArgs->geometry.x = 0; @@ -950,6 +956,7 @@ parseUserArguments(int argc, char *argv[], User_Arguments *userArgs) ECORE_GETOPT_VALUE_BOOL(userArgs->isFullscreen), ECORE_GETOPT_VALUE_PTR_CAST(userArgs->geometry), ECORE_GETOPT_VALUE_STR(userArgs->theme), + ECORE_GETOPT_VALUE_BOOL(userArgs->enableTiledBackingStore), ECORE_GETOPT_VALUE_STR(userArgs->userAgent), ECORE_GETOPT_VALUE_INT(verbose), ECORE_GETOPT_VALUE_BOOL(userArgs->quitOption), diff --git a/Tools/EWebLauncher/url_utils.c b/Tools/EWebLauncher/url_utils.c index fd92f145d..d8cf7cb49 100644 --- a/Tools/EWebLauncher/url_utils.c +++ b/Tools/EWebLauncher/url_utils.c @@ -39,7 +39,7 @@ char * url_from_user_input(const char *arg) { /* If it is already a URL, return the argument as is. */ - if (has_scheme(arg)) + if (has_scheme(arg) || !strcasecmp(arg, "about:blank")) return strdup(arg); Eina_Strbuf *buf = eina_strbuf_manage_new(eina_file_path_sanitize(arg)); diff --git a/Tools/GNUmakefile.am b/Tools/GNUmakefile.am index 87b8f6a52..6058be8ec 100644 --- a/Tools/GNUmakefile.am +++ b/Tools/GNUmakefile.am @@ -165,6 +165,7 @@ Programs_DumpRenderTree_CFLAGS = \ Programs_DumpRenderTree_LDADD = \ libjavascriptcoregtk-@WEBKITGTK_API_MAJOR_VERSION@.@WEBKITGTK_API_MINOR_VERSION@.la \ libwebkitgtk-@WEBKITGTK_API_MAJOR_VERSION@.@WEBKITGTK_API_MINOR_VERSION@.la \ + libWebCorePlatform.la \ libWebCoreModules.la \ libWebCoreInternals.la \ $(GLOBALDEPS_LIBS) \ diff --git a/Tools/MiniBrowser/efl/main.c b/Tools/MiniBrowser/efl/main.c index e029936a5..768e9ca33 100644 --- a/Tools/MiniBrowser/efl/main.c +++ b/Tools/MiniBrowser/efl/main.c @@ -43,21 +43,37 @@ static Eina_Bool encoding_detector_enabled = EINA_FALSE; static Eina_Bool frame_flattening_enabled = EINA_FALSE; static int window_width = 800; static int window_height = 600; +/* Default value of device_pixel_ratio is '0' so that we don't set custom device + * scale factor unless it's required by the User. */ +static double device_pixel_ratio = 0; -static Ewk_View_Smart_Class* miniBrowserViewSmartClass() +static Ewk_View_Smart_Class *miniBrowserViewSmartClass() { static Ewk_View_Smart_Class ewkViewClass = EWK_VIEW_SMART_CLASS_INIT_NAME_VERSION("MiniBrowser_View"); return &ewkViewClass; } typedef struct _Browser_Window { - Evas_Object *window; - Evas_Object *webview; + Evas_Object *elm_window; + Evas_Object *ewk_view; Evas_Object *url_bar; Evas_Object *back_button; Evas_Object *forward_button; } Browser_Window; +typedef struct _File_Selector_Data { + Browser_Window* parent; + Evas_Object *elm_window; + Ewk_File_Chooser_Request *request; +} File_Selector_Data; + +typedef struct _Auth_Data { + Evas_Object *popup; + Ewk_Auth_Request *request; + Evas_Object *username_entry; + Evas_Object *password_entry; +} Auth_Data; + static const Ecore_Getopt options = { "MiniBrowser", "%prog [options] [url]", @@ -70,6 +86,8 @@ static const Ecore_Getopt options = { ('e', "engine", "ecore-evas engine to use."), ECORE_GETOPT_STORE_STR ('s', "window-size", "window size in following format (width)x(height)."), + ECORE_GETOPT_STORE_DOUBLE + ('r', "device-pixel-ratio", "Ratio between the CSS units and device pixels."), ECORE_GETOPT_CALLBACK_NOARGS ('E', "list-engines", "list ecore-evas engines.", ecore_getopt_callback_ecore_evas_list_engines, NULL), @@ -87,45 +105,45 @@ static const Ecore_Getopt options = { } }; -static Browser_Window *window_create(const char *url); +static Browser_Window *window_create(const char *url, int width, int height); -static Browser_Window *browser_window_find(Evas_Object *window) +static Browser_Window *window_find_with_elm_window(Evas_Object *elm_window) { Eina_List *l; void *data; - if (!window) + if (!elm_window) return NULL; EINA_LIST_FOREACH(windows, l, data) { - Browser_Window *browser_window = (Browser_Window *)data; - if (browser_window->window == window) - return browser_window; + Browser_Window *window = (Browser_Window *)data; + if (window->elm_window == elm_window) + return window; } return NULL; } -static Browser_Window *browser_view_find(Evas_Object *view) +static Browser_Window *window_find_with_ewk_view(Evas_Object *ewk_view) { Eina_List *l; void *data; - if (!view) + if (!ewk_view) return NULL; EINA_LIST_FOREACH(windows, l, data) { - Browser_Window *browser_window = (Browser_Window *)data; - if (browser_window->webview == view) - return browser_window; + Browser_Window *window = (Browser_Window *)data; + if (window->ewk_view == ewk_view) + return window; } return NULL; } static void window_free(Browser_Window *window) { - evas_object_del(window->webview); + evas_object_del(window->ewk_view); /* The elm_win will take care of freeing its children */ - evas_object_del(window->window); + evas_object_del(window->elm_window); free(window); } @@ -139,9 +157,11 @@ static void window_close(Browser_Window *window) } static void -on_key_down(void *data, Evas *e, Evas_Object *obj, void *event_info) +on_key_down(void *user_data, Evas *e, Evas_Object *ewk_view, void *event_info) { + Browser_Window *window = (Browser_Window *)user_data; Evas_Event_Key_Down *ev = (Evas_Event_Key_Down*) event_info; + static const char *encodings[] = { "ISO-8859-1", "UTF-8", @@ -152,36 +172,40 @@ on_key_down(void *data, Evas *e, Evas_Object *obj, void *event_info) if (!strcmp(ev->key, "F1")) { info("Back (F1) was pressed\n"); - if (!ewk_view_back(obj)) + if (!ewk_view_back(ewk_view)) info("Back ignored: No back history\n"); } else if (!strcmp(ev->key, "F2")) { info("Forward (F2) was pressed\n"); - if (!ewk_view_forward(obj)) + if (!ewk_view_forward(ewk_view)) info("Forward ignored: No forward history\n"); } else if (!strcmp(ev->key, "F3")) { currentEncoding = (currentEncoding + 1) % (sizeof(encodings) / sizeof(encodings[0])); info("Set encoding (F3) pressed. New encoding to %s", encodings[currentEncoding]); - ewk_view_setting_encoding_custom_set(obj, encodings[currentEncoding]); + ewk_view_custom_encoding_set(ewk_view, encodings[currentEncoding]); } else if (!strcmp(ev->key, "F5")) { info("Reload (F5) was pressed, reloading.\n"); - ewk_view_reload(obj); + ewk_view_reload(ewk_view); } else if (!strcmp(ev->key, "F6")) { info("Stop (F6) was pressed, stop loading.\n"); - ewk_view_stop(obj); + ewk_view_stop(ewk_view); } else if (!strcmp(ev->key, "F7")) { - Ewk_Pagination_Mode mode = ewk_view_pagination_mode_get(obj); + Ewk_Pagination_Mode mode = ewk_view_pagination_mode_get(ewk_view); mode = (++mode) % (EWK_PAGINATION_MODE_BOTTOM_TO_TOP + 1); - if (ewk_view_pagination_mode_set(obj, mode)) + if (ewk_view_pagination_mode_set(ewk_view, mode)) info("Change Pagination Mode (F7) was pressed, changed to: %d\n", mode); else info("Change Pagination Mode (F7) was pressed, but NOT changed!"); } else if (!strcmp(ev->key, "n") && ctrlPressed) { info("Create new window (Ctrl+n) was pressed.\n"); - Browser_Window *window = window_create(DEFAULT_URL); + Browser_Window *window = window_create(DEFAULT_URL, 0, 0); + // 0 equals default width and height. windows = eina_list_append(windows, window); } else if (!strcmp(ev->key, "i") && ctrlPressed) { info("Show Inspector (Ctrl+i) was pressed.\n"); - ewk_view_inspector_show(obj); + ewk_view_inspector_show(ewk_view); + } else if (!strcmp(ev->key, "Escape")) { + if (elm_win_fullscreen_get(window->elm_window)) + ewk_view_fullscreen_exit(ewk_view); } } @@ -191,12 +215,12 @@ view_focus_set(Browser_Window *window, Eina_Bool focus) /* We steal focus away from elm's focus model and start to do things * manually here, so elm now has no clue what's up. Tell elm that its * toplevel widget is to be unfocused so elm gives up the focus */ - elm_object_focus_set(elm_object_top_widget_get(window->window), EINA_FALSE); - evas_object_focus_set(window->webview, focus); + elm_object_focus_set(elm_object_top_widget_get(window->elm_window), EINA_FALSE); + evas_object_focus_set(window->ewk_view, focus); } static void -on_mouse_down(void *user_data, Evas *e, Evas_Object *webview, void *event_info) +on_mouse_down(void *user_data, Evas *e, Evas_Object *ewk_view, void *event_info) { Browser_Window *window = (Browser_Window *)user_data; Evas_Event_Mouse_Down *ev = (Evas_Event_Mouse_Down *)event_info; @@ -207,16 +231,16 @@ on_mouse_down(void *user_data, Evas *e, Evas_Object *webview, void *event_info) if (ev->button == 1) view_focus_set(window, EINA_TRUE); else if (ev->button == 2) - view_focus_set(window, !evas_object_focus_get(webview)); + view_focus_set(window, !evas_object_focus_get(ewk_view)); } static void -title_set(Evas_Object *window, const char *title, int progress) +title_set(Evas_Object *elm_window, const char *title, int progress) { Eina_Strbuf *buffer; if (!title || !*title) { - elm_win_title_set(window, APP_NAME); + elm_win_title_set(elm_window, APP_NAME); return; } @@ -226,68 +250,53 @@ title_set(Evas_Object *window, const char *title, int progress) else eina_strbuf_append_printf(buffer, "%s - %s", title, APP_NAME); - elm_win_title_set(window, eina_strbuf_string_get(buffer)); + elm_win_title_set(elm_window, eina_strbuf_string_get(buffer)); eina_strbuf_free(buffer); } static void -on_title_changed(void *user_data, Evas_Object *webview, void *event_info) +on_title_changed(void *user_data, Evas_Object *ewk_view, void *event_info) { Browser_Window *window = (Browser_Window *)user_data; const char *title = (const char *)event_info; - title_set(window->window, title, 100); + title_set(window->elm_window, title, 100); } static void -on_url_changed(void *user_data, Evas_Object *webview, void *event_info) +on_url_changed(void *user_data, Evas_Object *ewk_view, void *event_info) { Browser_Window *window = (Browser_Window *)user_data; - char *url = elm_entry_utf8_to_markup(ewk_view_url_get(window->webview)); + char *url = elm_entry_utf8_to_markup(ewk_view_url_get(window->ewk_view)); elm_entry_entry_set(window->url_bar, url); free(url); } static void -on_back_forward_list_changed(void *user_data, Evas_Object *webview, void *event_info) +on_back_forward_list_changed(void *user_data, Evas_Object *ewk_view, void *event_info) { Browser_Window *window = (Browser_Window *)user_data; /* Update navigation buttons state */ - elm_object_disabled_set(window->back_button, !ewk_view_back_possible(webview)); - elm_object_disabled_set(window->forward_button, !ewk_view_forward_possible(webview)); + elm_object_disabled_set(window->back_button, !ewk_view_back_possible(ewk_view)); + elm_object_disabled_set(window->forward_button, !ewk_view_forward_possible(ewk_view)); } static void -on_new_window(void *user_data, Evas_Object *webview, void *event_info) -{ - Evas_Object **new_view = (Evas_Object **)event_info; - Browser_Window *window = window_create(NULL); - *new_view = window->webview; - windows = eina_list_append(windows, window); -} - -static void -on_close_window(void *user_data, Evas_Object *webview, void *event_info) -{ - window_close((Browser_Window *)user_data); -} - -static void -on_progress(void *user_data, Evas_Object *webview, void *event_info) +on_progress(void *user_data, Evas_Object *ewk_view, void *event_info) { Browser_Window *window = (Browser_Window *)user_data; double progress = *(double *)event_info; - title_set(window->window, ewk_view_title_get(window->webview), progress * 100); + title_set(window->elm_window, ewk_view_title_get(window->ewk_view), progress * 100); } static void -on_error(void *user_data, Evas_Object *webview, void *event_info) +on_error(void *user_data, Evas_Object *ewk_view, void *event_info) { - Eina_Strbuf* buffer; + Eina_Strbuf *buffer; const Ewk_Error *error = (const Ewk_Error *)event_info; /* This is a cancellation, do not display the error page */ @@ -298,12 +307,12 @@ on_error(void *user_data, Evas_Object *webview, void *event_info) eina_strbuf_append_printf(buffer, "<html><body><div style=\"color:#ff0000\">ERROR!</div><br><div>Code: %d<br>Description: %s<br>URL: %s</div></body</html>", ewk_error_code_get(error), ewk_error_description_get(error), ewk_error_url_get(error)); - ewk_view_html_string_load(webview, eina_strbuf_string_get(buffer), 0, ewk_error_url_get(error)); + ewk_view_html_string_load(ewk_view, eina_strbuf_string_get(buffer), 0, ewk_error_url_get(error)); eina_strbuf_free(buffer); } static void -on_download_request(void *user_data, Evas_Object *webview, void *event_info) +on_download_request(void *user_data, Evas_Object *ewk_view, void *event_info) { Ewk_Download_Job *download = (Ewk_Download_Job *)event_info; @@ -324,38 +333,32 @@ on_download_request(void *user_data, Evas_Object *webview, void *event_info) eina_strbuf_free(destination_path); } -typedef struct { - Evas_Object *parent; - Evas_Object *window; - Ewk_File_Chooser_Request *request; -} FileSelectorData; - -static void on_filepicker_parent_deletion(void *user_data, Evas *evas, Evas_Object *window, void *event); +static void on_filepicker_parent_deletion(void *user_data, Evas *evas, Evas_Object *elm_window, void *event); -static void close_file_picker(FileSelectorData* fs_data) +static void close_file_picker(File_Selector_Data *fs_data) { - evas_object_event_callback_del(fs_data->parent, EVAS_CALLBACK_DEL, on_filepicker_parent_deletion); - evas_object_del(fs_data->window); + evas_object_event_callback_del(fs_data->parent->elm_window, EVAS_CALLBACK_DEL, on_filepicker_parent_deletion); + evas_object_del(fs_data->elm_window); ewk_object_unref(fs_data->request); free(fs_data); } static void -on_filepicker_parent_deletion(void *user_data, Evas *evas, Evas_Object *window, void *event) +on_filepicker_parent_deletion(void *user_data, Evas *evas, Evas_Object *elm_window, void *event) { - close_file_picker((FileSelectorData *)user_data); + close_file_picker((File_Selector_Data *)user_data); } static void -on_filepicker_deletion(void *user_data, Evas_Object *window, void *event_info) +on_filepicker_deletion(void *user_data, Evas_Object *elm_window, void *event_info) { - close_file_picker((FileSelectorData *)user_data); + close_file_picker((File_Selector_Data *)user_data); } static void on_fileselector_done(void *user_data, Evas_Object *file_selector, void *event_info) { - FileSelectorData *fs_data = (FileSelectorData *)user_data; + File_Selector_Data *fs_data = (File_Selector_Data *)user_data; const char *selected = (const char *)event_info; if (selected && *selected) @@ -365,47 +368,47 @@ on_fileselector_done(void *user_data, Evas_Object *file_selector, void *event_in } static void -on_file_chooser_request(void *user_data, Evas_Object *webview, void *event_info) +on_file_chooser_request(void *user_data, Evas_Object *ewk_view, void *event_info) { - Browser_Window *app_data = (Browser_Window *)user_data; + Browser_Window *window = (Browser_Window *)user_data; Ewk_File_Chooser_Request *request = (Ewk_File_Chooser_Request *)event_info; // Show basic file picker which does not currently support multiple files // or MIME type filtering. - Evas_Object *window = elm_win_add(app_data->window, "file-picker-window", ELM_WIN_DIALOG_BASIC); - elm_win_title_set(window, "File picker"); - elm_win_modal_set(window, EINA_TRUE); + Evas_Object *elm_window = elm_win_add(window->elm_window, "file-picker-window", ELM_WIN_DIALOG_BASIC); + elm_win_title_set(elm_window, "File picker"); + elm_win_modal_set(elm_window, EINA_TRUE); - FileSelectorData* fs_data = (FileSelectorData*)malloc(sizeof(FileSelectorData)); - fs_data->parent = app_data->window; - fs_data->window = window; + File_Selector_Data *fs_data = (File_Selector_Data *)malloc(sizeof(File_Selector_Data)); + fs_data->parent = window; + fs_data->elm_window = elm_window; fs_data->request = ewk_object_ref(request); - evas_object_smart_callback_add(window, "delete,request", on_filepicker_deletion, fs_data); - evas_object_event_callback_add(app_data->window, EVAS_CALLBACK_DEL, on_filepicker_parent_deletion, fs_data); + evas_object_smart_callback_add(elm_window, "delete,request", on_filepicker_deletion, fs_data); + evas_object_event_callback_add(window->elm_window, EVAS_CALLBACK_DEL, on_filepicker_parent_deletion, fs_data); - Evas_Object *file_selector = elm_fileselector_add(window); + Evas_Object *file_selector = elm_fileselector_add(elm_window); const char *home_path = getenv("HOME"); elm_fileselector_path_set(file_selector, home_path ? home_path : "/home"); evas_object_size_hint_weight_set(file_selector, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(window, file_selector); + elm_win_resize_object_add(elm_window, file_selector); evas_object_show(file_selector); evas_object_smart_callback_add(file_selector, "done", on_fileselector_done, fs_data); - evas_object_resize(window, 400, 400); - elm_win_center(window, EINA_TRUE, EINA_TRUE); - evas_object_show(window); + evas_object_resize(elm_window, 400, 400); + elm_win_center(elm_window, EINA_TRUE, EINA_TRUE); + evas_object_show(elm_window); } static void -on_download_finished(void *user_data, Evas_Object *webview, void *event_info) +on_download_finished(void *user_data, Evas_Object *ewk_view, void *event_info) { Ewk_Download_Job *download = (Ewk_Download_Job *)event_info; info("Download finished: %s\n", ewk_download_job_destination_get(download)); } static void -on_download_failed(void *user_data, Evas_Object *webview, void *event_info) +on_download_failed(void *user_data, Evas_Object *ewk_view, void *event_info) { info("Download failed!\n"); } @@ -413,12 +416,12 @@ on_download_failed(void *user_data, Evas_Object *webview, void *event_info) static void on_favicon_received(const char *page_url, Evas_Object *icon, void *event_info) { - Browser_Window *app_data = (Browser_Window *)event_info; - if (strcmp(page_url, ewk_view_url_get(app_data->webview))) + Browser_Window *window = (Browser_Window *)event_info; + if (strcmp(page_url, ewk_view_url_get(window->ewk_view))) return; /* Remove previous icon from URL bar */ - Evas_Object *old_icon = elm_object_part_content_unset(app_data->url_bar, "icon"); + Evas_Object *old_icon = elm_object_part_content_unset(window->url_bar, "icon"); if (old_icon) { evas_object_unref(old_icon); evas_object_del(old_icon); @@ -431,22 +434,22 @@ on_favicon_received(const char *page_url, Evas_Object *icon, void *event_info) evas_object_size_hint_min_set(icon, 48, 24); evas_object_image_filled_set(icon, EINA_FALSE); evas_object_image_fill_set(icon, 24, 0, 24, 24); - elm_object_part_content_set(app_data->url_bar, "icon", icon); + elm_object_part_content_set(window->url_bar, "icon", icon); evas_object_ref(icon); } } static void -on_view_icon_changed(void *user_data, Evas_Object *webview, void *event_info) +on_view_icon_changed(void *user_data, Evas_Object *ewk_view, void *event_info) { - Browser_Window *app_data = (Browser_Window *)user_data; + Browser_Window *window = (Browser_Window *)user_data; /* Retrieve the view's favicon */ - Ewk_Context *context = ewk_view_context_get(webview); + Ewk_Context *context = ewk_view_context_get(ewk_view); Ewk_Favicon_Database *icon_database = ewk_context_favicon_database_get(context); - const char *page_url = ewk_view_url_get(webview); - Evas *evas = evas_object_evas_get(webview); - ewk_favicon_database_async_icon_get(icon_database, page_url, evas, on_favicon_received, app_data); + const char *page_url = ewk_view_url_get(ewk_view); + Evas *evas = evas_object_evas_get(ewk_view); + ewk_favicon_database_async_icon_get(icon_database, page_url, evas, on_favicon_received, window); } static int @@ -467,63 +470,63 @@ quit(Eina_Bool success, const char *msg) static void on_url_bar_activated(void *user_data, Evas_Object *url_bar, void *event_info) { - Browser_Window *app_data = (Browser_Window *)user_data; + Browser_Window *window = (Browser_Window *)user_data; const char *markup_url = elm_entry_entry_get(url_bar); char *user_url = elm_entry_markup_to_utf8(markup_url); char *url = url_from_user_input(user_url); - ewk_view_url_set(app_data->webview, url); + ewk_view_url_set(window->ewk_view, url); free(user_url); free(url); /* Give focus back to the view */ - view_focus_set(app_data, EINA_TRUE); + view_focus_set(window, EINA_TRUE); } static void on_url_bar_clicked(void *user_data, Evas_Object *url_bar, void *event_info) { - Browser_Window *app_data = (Browser_Window *)user_data; + Browser_Window *window = (Browser_Window *)user_data; /* Grab focus from the view */ - evas_object_focus_set(app_data->webview, EINA_FALSE); + evas_object_focus_set(window->ewk_view, EINA_FALSE); elm_object_focus_set(url_bar, EINA_TRUE); } static void on_back_button_clicked(void *user_data, Evas_Object *back_button, void *event_info) { - Browser_Window *app_data = (Browser_Window *)user_data; + Browser_Window *window = (Browser_Window *)user_data; - ewk_view_back(app_data->webview); + ewk_view_back(window->ewk_view); /* Update back button state */ - elm_object_disabled_set(back_button, !ewk_view_back_possible(app_data->webview)); + elm_object_disabled_set(back_button, !ewk_view_back_possible(window->ewk_view)); } static void on_forward_button_clicked(void *user_data, Evas_Object *forward_button, void *event_info) { - Browser_Window *app_data = (Browser_Window *)user_data; + Browser_Window *window = (Browser_Window *)user_data; - ewk_view_forward(app_data->webview); + ewk_view_forward(window->ewk_view); /* Update forward button state */ - elm_object_disabled_set(forward_button, !ewk_view_forward_possible(app_data->webview)); + elm_object_disabled_set(forward_button, !ewk_view_forward_possible(window->ewk_view)); } static void on_refresh_button_clicked(void *user_data, Evas_Object *refresh_button, void *event_info) { - Browser_Window *app_data = (Browser_Window *)user_data; + Browser_Window *window = (Browser_Window *)user_data; Evas *evas = evas_object_evas_get(refresh_button); Eina_Bool ctrlPressed = evas_key_modifier_is_set(evas_key_modifier_get(evas), "Control"); if (ctrlPressed) { info("Reloading and bypassing cache...\n"); - ewk_view_reload_bypass_cache(app_data->webview); + ewk_view_reload_bypass_cache(window->ewk_view); } else { info("Reloading...\n"); - ewk_view_reload(app_data->webview); + ewk_view_reload(window->ewk_view); } } @@ -545,9 +548,9 @@ on_ok_clicked(void *user_data, Evas_Object *obj, void *event_info) static void on_javascript_alert(Ewk_View_Smart_Data *smartData, const char *message) { - Browser_Window *window = browser_view_find(smartData->self); + Browser_Window *window = window_find_with_ewk_view(smartData->self); - Evas_Object *alert_popup = elm_popup_add(window->window); + Evas_Object *alert_popup = elm_popup_add(window->elm_window); evas_object_size_hint_weight_set(alert_popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); elm_object_text_set(alert_popup, message); elm_object_part_text_set(alert_popup, "title,text", "Alert"); @@ -569,11 +572,11 @@ on_javascript_alert(Ewk_View_Smart_Data *smartData, const char *message) static Eina_Bool on_javascript_confirm(Ewk_View_Smart_Data *smartData, const char *message) { - Browser_Window *window = browser_view_find(smartData->self); + Browser_Window *window = window_find_with_ewk_view(smartData->self); Eina_Bool ok = EINA_FALSE; - Evas_Object *confirm_popup = elm_popup_add(window->window); + Evas_Object *confirm_popup = elm_popup_add(window->elm_window); evas_object_size_hint_weight_set(confirm_popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); elm_object_text_set(confirm_popup, message); elm_object_part_text_set(confirm_popup, "title,text", "Confirmation"); @@ -601,29 +604,29 @@ on_javascript_confirm(Ewk_View_Smart_Data *smartData, const char *message) static const char * on_javascript_prompt(Ewk_View_Smart_Data *smartData, const char *message, const char *default_value) { - Browser_Window *window = browser_view_find(smartData->self); + Browser_Window *window = window_find_with_ewk_view(smartData->self); Eina_Bool ok = EINA_FALSE; - Evas_Object *prompt_popup = elm_popup_add(window->window); + Evas_Object *prompt_popup = elm_popup_add(window->elm_window); evas_object_size_hint_weight_set(prompt_popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); elm_object_part_text_set(prompt_popup, "title,text", "Prompt"); /* Popup Content */ - Evas_Object *box = elm_box_add(window->window); + Evas_Object *box = elm_box_add(window->elm_window); elm_box_padding_set(box, 0, 4); evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); evas_object_size_hint_align_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL); evas_object_show(box); - Evas_Object *prompt = elm_label_add(window->window); + Evas_Object *prompt = elm_label_add(window->elm_window); elm_object_text_set(prompt, message); evas_object_size_hint_weight_set(prompt, EVAS_HINT_EXPAND, 0.0); evas_object_size_hint_align_set(prompt, EVAS_HINT_FILL, 0.5); elm_box_pack_end(box, prompt); evas_object_show(prompt); - Evas_Object *entry = elm_entry_add(window->window); + Evas_Object *entry = elm_entry_add(window->elm_window); elm_entry_scrollable_set(entry, EINA_TRUE); elm_entry_single_line_set(entry, EINA_TRUE); elm_entry_text_style_user_push(entry, "DEFAULT='font_size=18'"); @@ -660,32 +663,127 @@ on_javascript_prompt(Ewk_View_Smart_Data *smartData, const char *message, const static Eina_Bool on_window_geometry_get(Ewk_View_Smart_Data *sd, Evas_Coord *x, Evas_Coord *y, Evas_Coord *width, Evas_Coord *height) { - Browser_Window *window = browser_view_find(sd->self); + Browser_Window *window = window_find_with_ewk_view(sd->self); - evas_object_geometry_get(window->window, x, y, width, height); + evas_object_geometry_get(window->elm_window, x, y, width, height); return EINA_TRUE; } static Eina_Bool on_window_geometry_set(Ewk_View_Smart_Data *sd, Evas_Coord x, Evas_Coord y, Evas_Coord width, Evas_Coord height) { - Browser_Window *window = browser_view_find(sd->self); + Browser_Window *window = window_find_with_ewk_view(sd->self); - evas_object_move(window->window, x, y); - evas_object_resize(window->window, width, height); + evas_object_move(window->elm_window, x, y); + evas_object_resize(window->elm_window, width, height); return EINA_TRUE; } typedef struct { - Evas_Object *popup; - Ewk_Auth_Request *request; - Evas_Object *username_entry; - Evas_Object *password_entry; -} AuthData; + Evas_Object *ewk_view; + Evas_Object *permission_popup; +} PermissionData; + +static void +on_fullscreen_accept(void *user_data, Evas_Object *obj, void *event_info) +{ + PermissionData *permission_data = (PermissionData *)user_data; + + evas_object_del(permission_data->permission_popup); + free(permission_data); +} static void -auth_popup_close(AuthData *auth_data) +on_fullscreen_deny(void *user_data, Evas_Object *obj, void *event_info) +{ + PermissionData *permission_data = (PermissionData *)user_data; + + ewk_view_fullscreen_exit(permission_data->ewk_view); + evas_object_del(permission_data->permission_popup); + free(permission_data); +} + +static Eina_Bool on_fullscreen_enter(Ewk_View_Smart_Data *sd, Ewk_Security_Origin *origin) +{ + Browser_Window *window = window_find_with_ewk_view(sd->self); + + /* Go fullscreen */ + elm_win_fullscreen_set(window->elm_window, EINA_TRUE); + + /* Show user popup */ + Evas_Object *permission_popup = elm_popup_add(window->elm_window); + evas_object_size_hint_weight_set(permission_popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + + Eina_Strbuf *message = eina_strbuf_new(); + eina_strbuf_append_printf(message, "%s is now fullscreen.<br>Press ESC at any time to exit fullscreen.<br>Allow fullscreen?", ewk_security_origin_host_get(origin)); + elm_object_text_set(permission_popup, eina_strbuf_string_get(message)); + eina_strbuf_free(message); + elm_object_part_text_set(permission_popup, "title,text", "Fullscreen Permission"); + + /* Popup buttons */ + PermissionData *permission_data = (PermissionData *)malloc(sizeof(PermissionData)); + permission_data->ewk_view = window->ewk_view; + permission_data->permission_popup = permission_popup; + Evas_Object *accept_button = elm_button_add(permission_popup); + elm_object_text_set(accept_button, "Accept"); + elm_object_part_content_set(permission_popup, "button1", accept_button); + evas_object_smart_callback_add(accept_button, "clicked", on_fullscreen_accept, permission_data); + + Evas_Object *deny_button = elm_button_add(permission_popup); + elm_object_text_set(deny_button, "Deny"); + elm_object_part_content_set(permission_popup, "button2", deny_button); + evas_object_smart_callback_add(deny_button, "clicked", on_fullscreen_deny, permission_data); + + evas_object_show(permission_popup); + + return EINA_TRUE; +} + +static Eina_Bool on_fullscreen_exit(Ewk_View_Smart_Data *sd) +{ + Browser_Window *window = window_find_with_ewk_view(sd->self); + + elm_win_fullscreen_set(window->elm_window, EINA_FALSE); + + return EINA_TRUE; +} + +static Evas_Object * +on_window_create(Ewk_View_Smart_Data *smartData, const Ewk_Window_Features *window_features) +{ + int x = 0; + int y = 0; + int width = 0; + int height = 0; + + ewk_window_features_geometry_get(window_features, &x, &y, &width, &height); + + if (!width) + width = window_width; + + if (!height) + height = window_height; + + Browser_Window *window = window_create(NULL, width, height); + Evas_Object *new_view = window->ewk_view; + + windows = eina_list_append(windows, window); + + info("minibrowser: location(%d,%d) size=(%d,%d)\n", x, y, width, height); + + return new_view; +} + +static void +on_window_close(Ewk_View_Smart_Data *smartData) +{ + Browser_Window *window = window_find_with_ewk_view(smartData->self); + window_close(window); +} + +static void +auth_popup_close(Auth_Data *auth_data) { ewk_object_unref(auth_data->request); evas_object_del(auth_data->popup); @@ -695,7 +793,7 @@ auth_popup_close(AuthData *auth_data) static void on_auth_cancel(void *user_data, Evas_Object *obj, void *event_info) { - AuthData *auth_data = (AuthData *)user_data; + Auth_Data *auth_data = (Auth_Data *)user_data; ewk_auth_request_cancel(auth_data->request); @@ -705,7 +803,7 @@ on_auth_cancel(void *user_data, Evas_Object *obj, void *event_info) static void on_auth_ok(void *user_data, Evas_Object *obj, void *event_info) { - AuthData *auth_data = (AuthData *)user_data; + Auth_Data *auth_data = (Auth_Data *)user_data; const char *username = elm_entry_entry_get(auth_data->username_entry); const char *password = elm_entry_entry_get(auth_data->password_entry); @@ -720,10 +818,10 @@ on_authentication_request(void *user_data, Evas_Object *obj, void *event_info) Browser_Window *window = (Browser_Window *)user_data; Ewk_Auth_Request *request = ewk_object_ref((Ewk_Auth_Request *)event_info); - AuthData *auth_data = (AuthData *)malloc(sizeof(AuthData)); + Auth_Data *auth_data = (Auth_Data *)malloc(sizeof(Auth_Data)); auth_data->request = request; - Evas_Object *auth_popup = elm_popup_add(window->window); + Evas_Object *auth_popup = elm_popup_add(window->elm_window); auth_data->popup = auth_popup; evas_object_size_hint_weight_set(auth_popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); elm_object_part_text_set(auth_popup, "title,text", "Authentication Required"); @@ -740,8 +838,8 @@ on_authentication_request(void *user_data, Evas_Object *obj, void *event_info) Evas_Object *label = elm_label_add(auth_popup); elm_label_line_wrap_set(label, ELM_WRAP_WORD); Eina_Strbuf *auth_text = eina_strbuf_new(); - const char* host = ewk_auth_request_host_get(request); - const char* realm = ewk_auth_request_realm_get(request); + const char *host = ewk_auth_request_host_get(request); + const char *realm = ewk_auth_request_realm_get(request); eina_strbuf_append_printf(auth_text, "A username and password are being requested by %s. The site says: \"%s\"", host, realm ? realm : ""); elm_object_text_set(label, eina_strbuf_string_get(auth_text)); eina_strbuf_free(auth_text); @@ -815,10 +913,10 @@ static void on_tooltip_text_set(void *user_data, Evas_Object *obj, void *event_info) { Browser_Window *window = (Browser_Window *)user_data; - const char* message = (const char*)event_info; + const char *message = (const char*)event_info; - elm_object_tooltip_text_set(window->webview, message); - elm_object_tooltip_show(window->webview); + elm_object_tooltip_text_set(window->ewk_view, message); + elm_object_tooltip_show(window->ewk_view); } static void @@ -826,29 +924,29 @@ on_tooltip_text_unset(void *user_data, Evas_Object *obj, void *event_info) { Browser_Window *window = (Browser_Window *)user_data; - elm_object_tooltip_unset(window->webview); + elm_object_tooltip_unset(window->ewk_view); } static void on_home_button_clicked(void *user_data, Evas_Object *home_button, void *event_info) { - Browser_Window *app_data = (Browser_Window *)user_data; + Browser_Window *window = (Browser_Window *)user_data; - ewk_view_url_set(app_data->webview, DEFAULT_URL); + ewk_view_url_set(window->ewk_view, DEFAULT_URL); } static void -on_window_deletion(void *user_data, Evas_Object *window, void *event_info) +on_window_deletion(void *user_data, Evas_Object *elm_window, void *event_info) { - window_close(browser_window_find(window)); + window_close(window_find_with_elm_window(elm_window)); } static Evas_Object * -create_toolbar_button(Evas_Object *window, const char *icon_name) +create_toolbar_button(Evas_Object *elm_window, const char *icon_name) { - Evas_Object *button = elm_button_add(window); + Evas_Object *button = elm_button_add(elm_window); - Evas_Object *icon = elm_icon_add(window); + Evas_Object *icon = elm_icon_add(elm_window); elm_icon_standard_set(icon, icon_name); evas_object_size_hint_max_set(icon, TOOL_BAR_ICON_SIZE, TOOL_BAR_ICON_SIZE); evas_object_color_set(icon, 44, 44, 102, 128); @@ -859,35 +957,35 @@ create_toolbar_button(Evas_Object *window, const char *icon_name) return button; } -static Browser_Window *window_create(const char *url) +static Browser_Window *window_create(const char *url, int width, int height) { - Browser_Window *app_data = malloc(sizeof(Browser_Window)); - if (!app_data) { + Browser_Window *window = malloc(sizeof(Browser_Window)); + if (!window) { info("ERROR: could not create browser window.\n"); return NULL; } /* Create window */ - app_data->window = elm_win_add(NULL, "minibrowser-window", ELM_WIN_BASIC); - elm_win_title_set(app_data->window, APP_NAME); - evas_object_smart_callback_add(app_data->window, "delete,request", on_window_deletion, &app_data); + window->elm_window = elm_win_add(NULL, "minibrowser-window", ELM_WIN_BASIC); + elm_win_title_set(window->elm_window, APP_NAME); + evas_object_smart_callback_add(window->elm_window, "delete,request", on_window_deletion, &window); /* Create window background */ - Evas_Object *bg = elm_bg_add(app_data->window); + Evas_Object *bg = elm_bg_add(window->elm_window); elm_bg_color_set(bg, 193, 192, 191); evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(app_data->window, bg); + elm_win_resize_object_add(window->elm_window, bg); evas_object_show(bg); /* Create vertical layout */ - Evas_Object *vertical_layout = elm_box_add(app_data->window); + Evas_Object *vertical_layout = elm_box_add(window->elm_window); elm_box_padding_set(vertical_layout, 0, 2); evas_object_size_hint_weight_set(vertical_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(app_data->window, vertical_layout); + elm_win_resize_object_add(window->elm_window, vertical_layout); evas_object_show(vertical_layout); /* Create horizontal layout for top bar */ - Evas_Object *horizontal_layout = elm_box_add(app_data->window); + Evas_Object *horizontal_layout = elm_box_add(window->elm_window); elm_box_horizontal_set(horizontal_layout, EINA_TRUE); evas_object_size_hint_weight_set(horizontal_layout, EVAS_HINT_EXPAND, 0.0); evas_object_size_hint_align_set(horizontal_layout, EVAS_HINT_FILL, 0.0); @@ -895,106 +993,110 @@ static Browser_Window *window_create(const char *url) evas_object_show(horizontal_layout); /* Create Back button */ - app_data->back_button = create_toolbar_button(app_data->window, "arrow_left"); - evas_object_smart_callback_add(app_data->back_button, "clicked", on_back_button_clicked, app_data); - elm_object_disabled_set(app_data->back_button, EINA_TRUE); - evas_object_size_hint_weight_set(app_data->back_button, 0.0, EVAS_HINT_EXPAND); - evas_object_size_hint_align_set(app_data->back_button, 0.0, 0.5); - elm_box_pack_end(horizontal_layout, app_data->back_button); - evas_object_show(app_data->back_button); + window->back_button = create_toolbar_button(window->elm_window, "arrow_left"); + evas_object_smart_callback_add(window->back_button, "clicked", on_back_button_clicked, window); + elm_object_disabled_set(window->back_button, EINA_TRUE); + evas_object_size_hint_weight_set(window->back_button, 0.0, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(window->back_button, 0.0, 0.5); + elm_box_pack_end(horizontal_layout, window->back_button); + evas_object_show(window->back_button); /* Create Forward button */ - app_data->forward_button = create_toolbar_button(app_data->window, "arrow_right"); - evas_object_smart_callback_add(app_data->forward_button, "clicked", on_forward_button_clicked, app_data); - elm_object_disabled_set(app_data->forward_button, EINA_TRUE); - evas_object_size_hint_weight_set(app_data->forward_button, 0.0, EVAS_HINT_EXPAND); - evas_object_size_hint_align_set(app_data->forward_button, 0.0, 0.5); - elm_box_pack_end(horizontal_layout, app_data->forward_button); - evas_object_show(app_data->forward_button); + window->forward_button = create_toolbar_button(window->elm_window, "arrow_right"); + evas_object_smart_callback_add(window->forward_button, "clicked", on_forward_button_clicked, window); + elm_object_disabled_set(window->forward_button, EINA_TRUE); + evas_object_size_hint_weight_set(window->forward_button, 0.0, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(window->forward_button, 0.0, 0.5); + elm_box_pack_end(horizontal_layout, window->forward_button); + evas_object_show(window->forward_button); /* Create URL bar */ - app_data->url_bar = elm_entry_add(app_data->window); - elm_entry_scrollable_set(app_data->url_bar, EINA_TRUE); - elm_entry_scrollbar_policy_set(app_data->url_bar, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF); - elm_entry_single_line_set(app_data->url_bar, EINA_TRUE); - elm_entry_cnp_mode_set(app_data->url_bar, ELM_CNP_MODE_PLAINTEXT); - elm_entry_text_style_user_push(app_data->url_bar, "DEFAULT='font_size=18'"); - evas_object_smart_callback_add(app_data->url_bar, "activated", on_url_bar_activated, app_data); - evas_object_smart_callback_add(app_data->url_bar, "clicked", on_url_bar_clicked, app_data); - evas_object_size_hint_weight_set(app_data->url_bar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - evas_object_size_hint_align_set(app_data->url_bar, EVAS_HINT_FILL, EVAS_HINT_FILL); - elm_box_pack_end(horizontal_layout, app_data->url_bar); - evas_object_show(app_data->url_bar); + window->url_bar = elm_entry_add(window->elm_window); + elm_entry_scrollable_set(window->url_bar, EINA_TRUE); + elm_entry_scrollbar_policy_set(window->url_bar, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF); + elm_entry_single_line_set(window->url_bar, EINA_TRUE); + elm_entry_cnp_mode_set(window->url_bar, ELM_CNP_MODE_PLAINTEXT); + elm_entry_text_style_user_push(window->url_bar, "DEFAULT='font_size=18'"); + evas_object_smart_callback_add(window->url_bar, "activated", on_url_bar_activated, window); + evas_object_smart_callback_add(window->url_bar, "clicked", on_url_bar_clicked, window); + evas_object_size_hint_weight_set(window->url_bar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(window->url_bar, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_box_pack_end(horizontal_layout, window->url_bar); + evas_object_show(window->url_bar); /* Create Refresh button */ - Evas_Object *refresh_button = create_toolbar_button(app_data->window, "refresh"); - evas_object_smart_callback_add(refresh_button, "clicked", on_refresh_button_clicked, app_data); + Evas_Object *refresh_button = create_toolbar_button(window->elm_window, "refresh"); + evas_object_smart_callback_add(refresh_button, "clicked", on_refresh_button_clicked, window); evas_object_size_hint_weight_set(refresh_button, 0.0, EVAS_HINT_EXPAND); evas_object_size_hint_align_set(refresh_button, 1.0, 0.5); elm_box_pack_end(horizontal_layout, refresh_button); evas_object_show(refresh_button); /* Create Home button */ - Evas_Object *home_button = create_toolbar_button(app_data->window, "home"); - evas_object_smart_callback_add(home_button, "clicked", on_home_button_clicked, app_data); + Evas_Object *home_button = create_toolbar_button(window->elm_window, "home"); + evas_object_smart_callback_add(home_button, "clicked", on_home_button_clicked, window); evas_object_size_hint_weight_set(home_button, 0.0, EVAS_HINT_EXPAND); evas_object_size_hint_align_set(home_button, 1.0, 0.5); elm_box_pack_end(horizontal_layout, home_button); evas_object_show(home_button); - /* Create webview */ + /* Create ewk_view */ Ewk_View_Smart_Class *ewkViewClass = miniBrowserViewSmartClass(); ewkViewClass->run_javascript_alert = on_javascript_alert; ewkViewClass->run_javascript_confirm = on_javascript_confirm; ewkViewClass->run_javascript_prompt = on_javascript_prompt; ewkViewClass->window_geometry_get = on_window_geometry_get; ewkViewClass->window_geometry_set = on_window_geometry_set; + ewkViewClass->fullscreen_enter = on_fullscreen_enter; + ewkViewClass->fullscreen_exit = on_fullscreen_exit; + ewkViewClass->window_create = on_window_create; + ewkViewClass->window_close = on_window_close; - Evas *evas = evas_object_evas_get(app_data->window); + Evas *evas = evas_object_evas_get(window->elm_window); Evas_Smart *smart = evas_smart_class_new(&ewkViewClass->sc); - app_data->webview = ewk_view_smart_add(evas, smart, ewk_context_default_get()); - ewk_view_theme_set(app_data->webview, THEME_DIR "/default.edj"); + window->ewk_view = ewk_view_smart_add(evas, smart, ewk_context_default_get()); + ewk_view_theme_set(window->ewk_view, THEME_DIR "/default.edj"); + if (device_pixel_ratio) + ewk_view_device_pixel_ratio_set(window->ewk_view, (float)device_pixel_ratio); - Ewk_Settings *settings = ewk_view_settings_get(app_data->webview); + Ewk_Settings *settings = ewk_view_settings_get(window->ewk_view); ewk_settings_file_access_from_file_urls_allowed_set(settings, EINA_TRUE); ewk_settings_encoding_detector_enabled_set(settings, encoding_detector_enabled); ewk_settings_frame_flattening_enabled_set(settings, frame_flattening_enabled); ewk_settings_developer_extras_enabled_set(settings, EINA_TRUE); ewk_settings_preferred_minimum_contents_width_set(settings, 0); - evas_object_smart_callback_add(app_data->webview, "authentication,request", on_authentication_request, app_data); - evas_object_smart_callback_add(app_data->webview, "close,window", on_close_window, app_data); - evas_object_smart_callback_add(app_data->webview, "create,window", on_new_window, app_data); - evas_object_smart_callback_add(app_data->webview, "download,failed", on_download_failed, app_data); - evas_object_smart_callback_add(app_data->webview, "download,finished", on_download_finished, app_data); - evas_object_smart_callback_add(app_data->webview, "download,request", on_download_request, app_data); - evas_object_smart_callback_add(app_data->webview, "file,chooser,request", on_file_chooser_request, app_data); - evas_object_smart_callback_add(app_data->webview, "icon,changed", on_view_icon_changed, app_data); - evas_object_smart_callback_add(app_data->webview, "load,error", on_error, app_data); - evas_object_smart_callback_add(app_data->webview, "load,progress", on_progress, app_data); - evas_object_smart_callback_add(app_data->webview, "title,changed", on_title_changed, app_data); - evas_object_smart_callback_add(app_data->webview, "url,changed", on_url_changed, app_data); - evas_object_smart_callback_add(app_data->webview, "back,forward,list,changed", on_back_forward_list_changed, app_data); - evas_object_smart_callback_add(app_data->webview, "tooltip,text,set", on_tooltip_text_set, app_data); - evas_object_smart_callback_add(app_data->webview, "tooltip,text,unset", on_tooltip_text_unset, app_data); - - evas_object_event_callback_add(app_data->webview, EVAS_CALLBACK_KEY_DOWN, on_key_down, app_data); - evas_object_event_callback_add(app_data->webview, EVAS_CALLBACK_MOUSE_DOWN, on_mouse_down, app_data); - - evas_object_size_hint_weight_set(app_data->webview, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - evas_object_size_hint_align_set(app_data->webview, EVAS_HINT_FILL, EVAS_HINT_FILL); - elm_box_pack_end(vertical_layout, app_data->webview); - evas_object_show(app_data->webview); + evas_object_smart_callback_add(window->ewk_view, "authentication,request", on_authentication_request, window); + evas_object_smart_callback_add(window->ewk_view, "download,failed", on_download_failed, window); + evas_object_smart_callback_add(window->ewk_view, "download,finished", on_download_finished, window); + evas_object_smart_callback_add(window->ewk_view, "download,request", on_download_request, window); + evas_object_smart_callback_add(window->ewk_view, "file,chooser,request", on_file_chooser_request, window); + evas_object_smart_callback_add(window->ewk_view, "icon,changed", on_view_icon_changed, window); + evas_object_smart_callback_add(window->ewk_view, "load,error", on_error, window); + evas_object_smart_callback_add(window->ewk_view, "load,progress", on_progress, window); + evas_object_smart_callback_add(window->ewk_view, "title,changed", on_title_changed, window); + evas_object_smart_callback_add(window->ewk_view, "url,changed", on_url_changed, window); + evas_object_smart_callback_add(window->ewk_view, "back,forward,list,changed", on_back_forward_list_changed, window); + evas_object_smart_callback_add(window->ewk_view, "tooltip,text,set", on_tooltip_text_set, window); + evas_object_smart_callback_add(window->ewk_view, "tooltip,text,unset", on_tooltip_text_unset, window); + + evas_object_event_callback_add(window->ewk_view, EVAS_CALLBACK_KEY_DOWN, on_key_down, window); + evas_object_event_callback_add(window->ewk_view, EVAS_CALLBACK_MOUSE_DOWN, on_mouse_down, window); + + evas_object_size_hint_weight_set(window->ewk_view, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(window->ewk_view, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_box_pack_end(vertical_layout, window->ewk_view); + evas_object_show(window->ewk_view); if (url) - ewk_view_url_set(app_data->webview, url); + ewk_view_url_set(window->ewk_view, url); - evas_object_resize(app_data->window, window_width, window_height); - evas_object_show(app_data->window); + evas_object_resize(window->elm_window, width ? width : window_width, height ? height : window_height); + evas_object_show(window->elm_window); - view_focus_set(app_data, EINA_TRUE); + view_focus_set(window, EINA_TRUE); - return app_data; + return window; } static void @@ -1033,6 +1135,7 @@ elm_main(int argc, char *argv[]) Ecore_Getopt_Value values[] = { ECORE_GETOPT_VALUE_STR(evas_engine_name), ECORE_GETOPT_VALUE_STR(window_size_string), + ECORE_GETOPT_VALUE_DOUBLE(device_pixel_ratio), ECORE_GETOPT_VALUE_BOOL(quitOption), ECORE_GETOPT_VALUE_BOOL(encoding_detector_enabled), ECORE_GETOPT_VALUE_BOOL(frame_flattening_enabled), @@ -1074,10 +1177,10 @@ elm_main(int argc, char *argv[]) if (args < argc) { char *url = url_from_user_input(argv[args]); - window = window_create(url); + window = window_create(url, 0, 0); free(url); } else - window = window_create(DEFAULT_URL); + window = window_create(DEFAULT_URL, 0, 0); if (!window) return quit(EINA_FALSE, "ERROR: could not create browser window.\n"); diff --git a/Tools/MiniBrowser/qt/MiniBrowserApplication.cpp b/Tools/MiniBrowser/qt/MiniBrowserApplication.cpp index ec919a6a7..d54cd669b 100644 --- a/Tools/MiniBrowser/qt/MiniBrowserApplication.cpp +++ b/Tools/MiniBrowser/qt/MiniBrowserApplication.cpp @@ -26,10 +26,14 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include "config.h" + #include "MiniBrowserApplication.h" #include "BrowserWindow.h" +#if HAVE(QTTESTSUPPORT) #include "QtTestSupport.h" +#endif #include "private/qquickwebview_p.h" #include "utils.h" #include <QRegExp> @@ -334,8 +338,10 @@ void MiniBrowserApplication::handleUserOptions() m_windowOptions.setRequestedWindowSize(QSize(list.at(0).toInt(), list.at(1).toInt())); } +#if HAVE(QTTESTSUPPORT) if (takeOptionFlag(&args, QStringLiteral("--use-test-fonts"))) WebKit::QtTestSupport::initializeTestFonts(); +#endif if (args.contains("-r")) { QString listFile = takeOptionValue(&args, "-r"); diff --git a/Tools/QueueStatusServer/model/queuepropertymixin_unittest.py b/Tools/QueueStatusServer/model/queuepropertymixin_unittest.py index 9a301fee7..e83c3f50d 100644 --- a/Tools/QueueStatusServer/model/queuepropertymixin_unittest.py +++ b/Tools/QueueStatusServer/model/queuepropertymixin_unittest.py @@ -42,10 +42,10 @@ class QueuePropertyMixinTest(unittest.TestCase): test_object = ObjectWithQueueName() mac_ews = Queue("mac-ews") test_object.queue = mac_ews - self.assertEquals(test_object.queue.name(), "mac-ews") - self.assertEquals(test_object.queue_name, "mac-ews") + self.assertEqual(test_object.queue.name(), "mac-ews") + self.assertEqual(test_object.queue_name, "mac-ews") test_object.queue = None - self.assertEquals(test_object.queue_name, None) + self.assertEqual(test_object.queue_name, None) if __name__ == '__main__': diff --git a/Tools/QueueStatusServer/model/queues_unittest.py b/Tools/QueueStatusServer/model/queues_unittest.py index cfa7fcdd2..654c8a62b 100644 --- a/Tools/QueueStatusServer/model/queues_unittest.py +++ b/Tools/QueueStatusServer/model/queues_unittest.py @@ -43,7 +43,7 @@ class QueueTest(unittest.TestCase): self.assertRaises(AssertionError, Queue, ("bogus")) def _assert_short_name(self, queue_name, short_name): - self.assertEquals(Queue(queue_name).short_name(), short_name) + self.assertEqual(Queue(queue_name).short_name(), short_name) def test_short_name(self): self._assert_short_name("mac-ews", "Mac") @@ -52,7 +52,7 @@ class QueueTest(unittest.TestCase): self._assert_short_name("style-queue", "Style") def _assert_display_name(self, queue_name, short_name): - self.assertEquals(Queue(queue_name).display_name(), short_name) + self.assertEqual(Queue(queue_name).display_name(), short_name) def test_display_name(self): self._assert_display_name("mac-ews", "Mac EWS") @@ -61,7 +61,7 @@ class QueueTest(unittest.TestCase): self._assert_display_name("style-queue", "Style Queue") def _assert_name_with_underscores(self, queue_name, short_name): - self.assertEquals(Queue(queue_name).name_with_underscores(), short_name) + self.assertEqual(Queue(queue_name).name_with_underscores(), short_name) def test_name_with_underscores(self): self._assert_name_with_underscores("mac-ews", "mac_ews") diff --git a/Tools/QueueStatusServer/model/workitems_unittest.py b/Tools/QueueStatusServer/model/workitems_unittest.py index b1ff1d315..f6ca78559 100644 --- a/Tools/QueueStatusServer/model/workitems_unittest.py +++ b/Tools/QueueStatusServer/model/workitems_unittest.py @@ -36,9 +36,9 @@ class WorkItemsTest(unittest.TestCase): def test_display_position_for_attachment(self): items = WorkItems() items.item_ids = [0, 1, 2] - self.assertEquals(items.display_position_for_attachment(0), 1) - self.assertEquals(items.display_position_for_attachment(1), 2) - self.assertEquals(items.display_position_for_attachment(3), None) + self.assertEqual(items.display_position_for_attachment(0), 1) + self.assertEqual(items.display_position_for_attachment(1), 2) + self.assertEqual(items.display_position_for_attachment(3), None) if __name__ == '__main__': diff --git a/Tools/Scripts/build-webkit b/Tools/Scripts/build-webkit index f36abef90..3e53fa26d 100755 --- a/Tools/Scripts/build-webkit +++ b/Tools/Scripts/build-webkit @@ -450,11 +450,11 @@ sub writeCongrats() my $buildTime = formatBuildTime($endTime - $startTime); print "\n"; - print "===========================================================\n"; + print "====================================================================\n"; print " WebKit is now built ($buildTime). \n"; if (!isChromium()) { print " To run $launcherName with this newly-built code, use the\n"; print " \"$launcherPath\" script.\n"; } - print "===========================================================\n"; + print "====================================================================\n"; } diff --git a/Tools/Scripts/copy-webkitlibraries-to-product-directory b/Tools/Scripts/copy-webkitlibraries-to-product-directory index dd6f29d0e..67a1e3b21 100755 --- a/Tools/Scripts/copy-webkitlibraries-to-product-directory +++ b/Tools/Scripts/copy-webkitlibraries-to-product-directory @@ -34,8 +34,6 @@ $productDir = $ENV{BUILT_PRODUCTS_DIR} if !$productDir; chdirWebKit(); my @librariesToCopy = ( - "libWebKitSystemInterfaceLeopard.a", - "libWebKitSystemInterfaceSnowLeopard.a", "libWebKitSystemInterfaceLion.a", "libWebKitSystemInterfaceMountainLion.a", "libWebCoreSQLite3.a", diff --git a/Tools/Scripts/lint-webkitpy b/Tools/Scripts/lint-webkitpy index 0fbbd73ca..22de981e7 100755 --- a/Tools/Scripts/lint-webkitpy +++ b/Tools/Scripts/lint-webkitpy @@ -27,14 +27,8 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import os import sys -from webkitpy.thirdparty.autoinstalled.pylint import lint +from webkitpy.style.checkers.python import Pylinter -script_dir = os.path.abspath(os.path.dirname(__file__)) -if not script_dir in sys.path: - sys.path.append(script_dir) - -pylintrc = os.path.join(script_dir, 'webkitpy', 'pylintrc') -lint.Run(['--rcfile', pylintrc, '-f', 'parseable' ] + sys.argv[1:]) +sys.stdout.write(Pylinter().run(sys.argv[1:]).getvalue()) diff --git a/Tools/Scripts/old-run-webkit-tests b/Tools/Scripts/old-run-webkit-tests index ef3b197d4..e4803c9c6 100755 --- a/Tools/Scripts/old-run-webkit-tests +++ b/Tools/Scripts/old-run-webkit-tests @@ -423,6 +423,8 @@ my $productDir = productDir(); $productDir .= "/bin" if isQt(); $productDir .= "/Programs" if isGtk(); +# Save the current directory before chaging it via chdirWebKit +my $currentDir = cwd(); chdirWebKit(); if (!defined($root) && !$noBuildDumpTool) { @@ -467,7 +469,7 @@ my @platformTestHierarchy = buildPlatformTestHierarchy(@platformResultHierarchy) $expectedDirectory = $ENV{"WebKitExpectedTestResultsDirectory"} if $ENV{"WebKitExpectedTestResultsDirectory"}; -$testResultsDirectory = File::Spec->rel2abs($testResultsDirectory); +$testResultsDirectory = File::Spec->catfile($currentDir, $testResultsDirectory); # $testResultsDirectory must be empty before testing. rmtree $testResultsDirectory; my $testResults = File::Spec->catfile($testResultsDirectory, "results.html"); diff --git a/Tools/Scripts/run-api-tests b/Tools/Scripts/run-api-tests index 3a3e00cda..5913cee8f 100755 --- a/Tools/Scripts/run-api-tests +++ b/Tools/Scripts/run-api-tests @@ -79,6 +79,19 @@ if ($showHelp) { } setConfiguration(); + +# When running TestWebKitAPI for Chromium on Android, defer to the test runner in +# Chromium as we can't execute the binary locally. +if (isChromiumAndroid()) { + my @runTestCommand = ('build/android/run_tests.py', '--verbose', '--webkit', '--out-directory', sourceDir() . '/out', '-s', 'TestWebKitAPI'); + if (configuration() eq "Release") { + push @runTestCommand, '--release'; + } + + chdir(sourceDir() . '/Source/WebKit/chromium') or die $!; + exit exitStatus(system(@runTestCommand)); +} + buildTestTool() if $build; setPathForRunningWebKitApp(\%ENV); my @testsToRun = listAllTests(); diff --git a/Tools/Scripts/run-chromium-webkit-unit-tests b/Tools/Scripts/run-chromium-webkit-unit-tests index 43f85ad3e..33c7cc25e 100755 --- a/Tools/Scripts/run-chromium-webkit-unit-tests +++ b/Tools/Scripts/run-chromium-webkit-unit-tests @@ -34,7 +34,19 @@ use lib $FindBin::Bin; use webkitdirs; use VCSUtils; -push(@ARGV, "--chromium"); setConfiguration(); + +# Defer to Android's test runners for running webkit_unit_tests on a device. +if (checkForArgumentAndRemoveFromARGV('--platform=chromium-android')) { + my @runTestCommand = ('build/android/run_tests.py', '--verbose', '--webkit', '--out-directory', sourceDir() . '/out', '-s', 'webkit_unit_tests'); + if (configuration() eq "Release") { + push @runTestCommand, '--release'; + } + + chdir(sourceDir() . '/Source/WebKit/chromium') or die $!; + exit exitStatus(system(@runTestCommand)); +} + +push(@ARGV, "--chromium"); my $pathToBinary = productDir() . "/webkit_unit_tests"; exit exitStatus(system ($pathToBinary, @ARGV)); diff --git a/Tools/Scripts/webkitdirs.pm b/Tools/Scripts/webkitdirs.pm index 76770b706..619a76e19 100755 --- a/Tools/Scripts/webkitdirs.pm +++ b/Tools/Scripts/webkitdirs.pm @@ -1514,7 +1514,7 @@ sub launcherName() } elsif (isAppleWebKit()) { return "Safari"; } elsif (isEfl()) { - return "EWebLauncher"; + return "EWebLauncher/MiniBrowser"; } elsif (isWinCE()) { return "WinCELauncher"; } @@ -1873,9 +1873,13 @@ sub retrieveQMakespecVar sub qtMakeCommand($) { my ($qmakebin) = @_; - chomp(my $mkspec = `$qmakebin -query QT_HOST_DATA`); - $mkspec .= "/mkspecs/default"; - my $compiler = retrieveQMakespecVar("$mkspec/qmake.conf", "QMAKE_CC"); + chomp(my $hostDataPath = `$qmakebin -query QT_HOST_DATA`); + my $mkspecPath = $hostDataPath . "/mkspecs/default/qmake.conf"; + if (! -e $mkspecPath) { + chomp(my $mkspec= `$qmakebin -query QMAKE_XSPEC`); + $mkspecPath = $hostDataPath . "/mkspecs/" . $mkspec . "/qmake.conf"; + } + my $compiler = retrieveQMakespecVar($mkspecPath, "QMAKE_CC"); #print "default spec: " . $mkspec . "\n"; #print "compiler found: " . $compiler . "\n"; @@ -2281,14 +2285,14 @@ sub buildQMakeProjects my $buildHint = ""; - my $pathToQmakeCache = File::Spec->catfile($dir, ".qmake.cache"); - if (-e $pathToQmakeCache && open(QMAKECACHE, $pathToQmakeCache)) { - while (<QMAKECACHE>) { + my $pathToBuiltRevisions = File::Spec->catfile($dir, ".builtRevisions.cache"); + if (-e $pathToBuiltRevisions && open(BUILTREVISIONS, $pathToBuiltRevisions)) { + while (<BUILTREVISIONS>) { if ($_ =~ m/^SVN_REVISION\s=\s(\d+)$/) { $previousSvnRevision = $1; } } - close(QMAKECACHE); + close(BUILTREVISIONS); } my $result = 0; @@ -2356,9 +2360,9 @@ sub buildQMakeProjects if ($result eq 0) { # Now that the build completed successfully we can save the SVN revision - open(QMAKECACHE, ">>$pathToQmakeCache"); - print QMAKECACHE "SVN_REVISION = $svnRevision\n"; - close(QMAKECACHE); + open(BUILTREVISIONS, ">>$pathToBuiltRevisions"); + print BUILTREVISIONS "SVN_REVISION = $svnRevision\n"; + close(BUILTREVISIONS); } elsif (!$command =~ /incremental/ && exitStatus($result)) { my $exitCode = exitStatus($result); my $failMessage = <<EOF; diff --git a/Tools/Scripts/webkitperl/FeatureList.pm b/Tools/Scripts/webkitperl/FeatureList.pm index cc5f0de6e..6f7570ae2 100644 --- a/Tools/Scripts/webkitperl/FeatureList.pm +++ b/Tools/Scripts/webkitperl/FeatureList.pm @@ -111,6 +111,7 @@ my ( $orientationEventsSupport, $pageVisibilityAPISupport, $progressTagSupport, + $proximityEventsSupport, $quotaSupport, $resolutionMediaQuerySupport, $registerProtocolHandlerSupport, @@ -127,6 +128,7 @@ my ( $textAutosizingSupport, $tiledBackingStoreSupport, $touchEventsSupport, + $touchSliderSupport, $touchIconLoadingSupport, $vibrationSupport, $videoSupport, @@ -180,9 +182,6 @@ my @features = ( { option => "css3-text", desc => "Toggle CSS3 Text support", define => "ENABLE_CSS3_TEXT", default => isEfl(), value => \$css3TextSupport }, - { option => "css-hierarchies", desc => "Toggle CSS Hierarchy support", - define => "ENABLE_CSS_HIERARCHIES", default => 0, value => \$cssHierarchiesSupport }, - { option => "css-box-decoration-break", desc => "Toggle CSS box-decoration-break support", define => "ENABLE_CSS_BOX_DECORATION_BREAK", default => 1, value => \$cssBoxDecorationBreakSupport }, @@ -351,6 +350,9 @@ my @features = ( { option => "progress-tag", desc => "Toggle Progress Tag support", define => "ENABLE_PROGRESS_ELEMENT", default => 1, value => \$progressTagSupport }, + { option => "proximity-events", desc => "Toggle Proximity Events support", + define => "ENABLE_PROXIMITY_EVENTS", default => 0, value => \$proximityEventsSupport }, + { option => "quota", desc => "Toggle Quota support", define => "ENABLE_QUOTA", default => 0, value => \$quotaSupport }, @@ -396,6 +398,9 @@ my @features = ( { option => "touch-events", desc => "Toggle Touch Events support", define => "ENABLE_TOUCH_EVENTS", default => (isQt() || isBlackBerry() || isEfl()), value => \$touchEventsSupport }, + { option => "touch-slider", desc => "Toggle Touch Slider support", + define => "ENABLE_TOUCH_SLIDER", default => isBlackBerry(), value => \$touchSliderSupport }, + { option => "touch-icon-loading", desc => "Toggle Touch Icon Loading Support", define => "ENABLE_TOUCH_ICON_LOADING", default => 0, value => \$touchIconLoadingSupport }, diff --git a/Tools/Scripts/webkitpy/common/checkout/changelog_unittest.py b/Tools/Scripts/webkitpy/common/checkout/changelog_unittest.py index 9591744d1..fa2339f45 100644 --- a/Tools/Scripts/webkitpy/common/checkout/changelog_unittest.py +++ b/Tools/Scripts/webkitpy/common/checkout/changelog_unittest.py @@ -181,7 +181,7 @@ class ChangeLogTest(unittest.TestCase): ''' - self.assertEquals(56988, parse_bug_id_from_changelog(commit_text)) + self.assertEqual(56988, parse_bug_id_from_changelog(commit_text)) commit_text = ''' 2011-03-23 Ojan Vafai <ojan@chromium.org> @@ -194,7 +194,7 @@ class ChangeLogTest(unittest.TestCase): ''' - self.assertEquals(12345, parse_bug_id_from_changelog(commit_text)) + self.assertEqual(12345, parse_bug_id_from_changelog(commit_text)) commit_text = ''' 2011-03-31 Adam Roben <aroben@apple.com> @@ -213,7 +213,7 @@ class ChangeLogTest(unittest.TestCase): ''' - self.assertEquals(57569, parse_bug_id_from_changelog(commit_text)) + self.assertEqual(57569, parse_bug_id_from_changelog(commit_text)) commit_text = ''' 2011-03-29 Timothy Hatcher <timothy@apple.com> @@ -230,24 +230,24 @@ class ChangeLogTest(unittest.TestCase): extract-localizable-strings does not complain about unbalanced single quotes. ''' - self.assertEquals(57354, parse_bug_id_from_changelog(commit_text)) + self.assertEqual(57354, parse_bug_id_from_changelog(commit_text)) def test_parse_log_entries_from_changelog(self): changelog_file = StringIO(self._example_changelog) parsed_entries = list(ChangeLog.parse_entries_from_file(changelog_file)) - self.assertEquals(len(parsed_entries), 9) - self.assertEquals(parsed_entries[0].reviewer_text(), "David Levin") - self.assertEquals(parsed_entries[1].author_email(), "ddkilzer@apple.com") - self.assertEquals(parsed_entries[2].reviewer_text(), "Mark Rowe") - self.assertEquals(parsed_entries[2].touched_files(), ["DumpRenderTree/mac/DumpRenderTreeWindow.mm"]) - self.assertEquals(parsed_entries[3].author_name(), "Benjamin Poulain") - self.assertEquals(parsed_entries[3].touched_files(), ["platform/cf/KURLCFNet.cpp", "platform/mac/KURLMac.mm", + self.assertEqual(len(parsed_entries), 9) + self.assertEqual(parsed_entries[0].reviewer_text(), "David Levin") + self.assertEqual(parsed_entries[1].author_email(), "ddkilzer@apple.com") + self.assertEqual(parsed_entries[2].reviewer_text(), "Mark Rowe") + self.assertEqual(parsed_entries[2].touched_files(), ["DumpRenderTree/mac/DumpRenderTreeWindow.mm"]) + self.assertEqual(parsed_entries[3].author_name(), "Benjamin Poulain") + self.assertEqual(parsed_entries[3].touched_files(), ["platform/cf/KURLCFNet.cpp", "platform/mac/KURLMac.mm", "WebCoreSupport/ChromeClientEfl.cpp", "ewk/ewk_private.h", "ewk/ewk_view.cpp"]) - self.assertEquals(parsed_entries[4].reviewer_text(), "David Hyatt") - self.assertEquals(parsed_entries[5].reviewer_text(), "Adam Roben") - self.assertEquals(parsed_entries[6].reviewer_text(), "Tony Chang") - self.assertEquals(parsed_entries[7].reviewer_text(), None) - self.assertEquals(parsed_entries[8].reviewer_text(), 'Darin Adler') + self.assertEqual(parsed_entries[4].reviewer_text(), "David Hyatt") + self.assertEqual(parsed_entries[5].reviewer_text(), "Adam Roben") + self.assertEqual(parsed_entries[6].reviewer_text(), "Tony Chang") + self.assertEqual(parsed_entries[7].reviewer_text(), None) + self.assertEqual(parsed_entries[8].reviewer_text(), 'Darin Adler') def test_parse_log_entries_from_annotated_file(self): # Note that there are trailing spaces on some of the lines intentionally. @@ -285,28 +285,28 @@ class ChangeLogTest(unittest.TestCase): u"99187 andreas.kling@nokia.com \n") parsed_entries = list(ChangeLog.parse_entries_from_file(changelog_file)) - self.assertEquals(parsed_entries[0].revision(), 100000) - self.assertEquals(parsed_entries[0].reviewer_text(), "Zoltan Herczeg") - self.assertEquals(parsed_entries[0].author_name(), u"Csaba Osztrogon\u00e1c") - self.assertEquals(parsed_entries[0].author_email(), "ossy@webkit.org") - self.assertEquals(parsed_entries[1].revision(), 93798) - self.assertEquals(parsed_entries[1].author_name(), "Alexey Proskuryakov") - self.assertEquals(parsed_entries[2].revision(), 99190) - self.assertEquals(parsed_entries[2].author_name(), "Andreas Kling") - self.assertEquals(parsed_entries[3].revision(), 99187) - self.assertEquals(parsed_entries[3].author_name(), "Andreas Kling") + self.assertEqual(parsed_entries[0].revision(), 100000) + self.assertEqual(parsed_entries[0].reviewer_text(), "Zoltan Herczeg") + self.assertEqual(parsed_entries[0].author_name(), u"Csaba Osztrogon\u00e1c") + self.assertEqual(parsed_entries[0].author_email(), "ossy@webkit.org") + self.assertEqual(parsed_entries[1].revision(), 93798) + self.assertEqual(parsed_entries[1].author_name(), "Alexey Proskuryakov") + self.assertEqual(parsed_entries[2].revision(), 99190) + self.assertEqual(parsed_entries[2].author_name(), "Andreas Kling") + self.assertEqual(parsed_entries[3].revision(), 99187) + self.assertEqual(parsed_entries[3].author_name(), "Andreas Kling") def _assert_parse_reviewer_text_and_list(self, text, expected_reviewer_text, expected_reviewer_text_list=None): reviewer_text, reviewer_text_list = ChangeLogEntry._parse_reviewer_text(text) - self.assertEquals(reviewer_text, expected_reviewer_text) + self.assertEqual(reviewer_text, expected_reviewer_text) if expected_reviewer_text_list: - self.assertEquals(reviewer_text_list, expected_reviewer_text_list) + self.assertEqual(reviewer_text_list, expected_reviewer_text_list) else: - self.assertEquals(reviewer_text_list, [expected_reviewer_text]) + self.assertEqual(reviewer_text_list, [expected_reviewer_text]) def _assert_parse_reviewer_text_list(self, text, expected_reviewer_text_list): reviewer_text, reviewer_text_list = ChangeLogEntry._parse_reviewer_text(text) - self.assertEquals(reviewer_text_list, expected_reviewer_text_list) + self.assertEqual(reviewer_text_list, expected_reviewer_text_list) def test_parse_reviewer_text(self): self._assert_parse_reviewer_text_and_list(' reviewed by Ryosuke Niwa, Oliver Hunt, and Dimitri Glazkov', @@ -388,8 +388,8 @@ class ChangeLogTest(unittest.TestCase): def _assert_fuzzy_reviewer_match(self, reviewer_text, expected_text_list, expected_contributors): unused, reviewer_text_list = ChangeLogEntry._parse_reviewer_text(reviewer_text) - self.assertEquals(reviewer_text_list, expected_text_list) - self.assertEquals(self._entry_with_reviewer(reviewer_text).reviewers(), self._contributors(expected_contributors)) + self.assertEqual(reviewer_text_list, expected_text_list) + self.assertEqual(self._entry_with_reviewer(reviewer_text).reviewers(), self._contributors(expected_contributors)) def test_fuzzy_reviewer_match__none(self): self._assert_fuzzy_reviewer_match('Reviewed by BUILD FIX', ['BUILD FIX'], []) @@ -427,7 +427,7 @@ class ChangeLogTest(unittest.TestCase): def _assert_parse_authors(self, author_text, expected_contributors): parsed_authors = [(author['name'], author['email']) for author in self._entry_with_author(author_text).authors()] - self.assertEquals(parsed_authors, expected_contributors) + self.assertEqual(parsed_authors, expected_contributors) def test_parse_authors(self): self._assert_parse_authors(u'Aaron Colwell <acolwell@chromium.org>', [(u'Aaron Colwell', u'acolwell@chromium.org')]) @@ -458,11 +458,11 @@ class ChangeLogTest(unittest.TestCase): changelog_contents = u"%s\n%s" % (self._example_entry, self._example_changelog) changelog_file = StringIO(changelog_contents) latest_entry = ChangeLog.parse_latest_entry_from_file(changelog_file) - self.assertEquals(latest_entry.contents(), self._example_entry) - self.assertEquals(latest_entry.author_name(), "Peter Kasting") - self.assertEquals(latest_entry.author_email(), "pkasting@google.com") - self.assertEquals(latest_entry.reviewer_text(), u"Tor Arne Vestb\xf8") - self.assertEquals(latest_entry.touched_files(), ["DumpRenderTree/win/DumpRenderTree.vcproj", "DumpRenderTree/win/ImageDiff.vcproj", "DumpRenderTree/win/TestNetscapePlugin/TestNetscapePlugin.vcproj"]) + self.assertEqual(latest_entry.contents(), self._example_entry) + self.assertEqual(latest_entry.author_name(), "Peter Kasting") + self.assertEqual(latest_entry.author_email(), "pkasting@google.com") + self.assertEqual(latest_entry.reviewer_text(), u"Tor Arne Vestb\xf8") + self.assertEqual(latest_entry.touched_files(), ["DumpRenderTree/win/DumpRenderTree.vcproj", "DumpRenderTree/win/ImageDiff.vcproj", "DumpRenderTree/win/TestNetscapePlugin/TestNetscapePlugin.vcproj"]) self.assertTrue(latest_entry.reviewer()) # Make sure that our UTF8-based lookup of Tor works. @@ -470,8 +470,8 @@ class ChangeLogTest(unittest.TestCase): changelog_contents = u"%s\n%s" % (self._example_entry, self._rolled_over_footer) changelog_file = StringIO(changelog_contents) latest_entry = ChangeLog.parse_latest_entry_from_file(changelog_file) - self.assertEquals(latest_entry.contents(), self._example_entry) - self.assertEquals(latest_entry.author_name(), "Peter Kasting") + self.assertEqual(latest_entry.contents(), self._example_entry) + self.assertEqual(latest_entry.author_name(), "Peter Kasting") @staticmethod def _write_tmp_file_with_contents(byte_array): @@ -543,14 +543,14 @@ class ChangeLogTest(unittest.TestCase): actual_contents = self._read_file_contents(changelog_path, "utf-8") expected_contents = changelog_contents.replace('NOBODY (OOPS!)', reviewer_name) os.remove(changelog_path) - self.assertEquals(actual_contents.splitlines(), expected_contents.splitlines()) + self.assertEqual(actual_contents.splitlines(), expected_contents.splitlines()) changelog_contents_without_reviewer_line = u"%s\n%s" % (self._new_entry_boilerplate_without_reviewer_line, self._example_changelog) changelog_path = self._write_tmp_file_with_contents(changelog_contents_without_reviewer_line.encode("utf-8")) ChangeLog(changelog_path).set_reviewer(reviewer_name) actual_contents = self._read_file_contents(changelog_path, "utf-8") os.remove(changelog_path) - self.assertEquals(actual_contents.splitlines(), expected_contents.splitlines()) + self.assertEqual(actual_contents.splitlines(), expected_contents.splitlines()) changelog_contents_without_reviewer_line = u"%s\n%s" % (self._new_entry_boilerplate_without_reviewer_multiple_bugurl, self._example_changelog) changelog_path = self._write_tmp_file_with_contents(changelog_contents_without_reviewer_line.encode("utf-8")) @@ -559,7 +559,7 @@ class ChangeLogTest(unittest.TestCase): changelog_contents = u"%s\n%s" % (self._new_entry_boilerplate_with_multiple_bugurl, self._example_changelog) expected_contents = changelog_contents.replace('NOBODY (OOPS!)', reviewer_name) os.remove(changelog_path) - self.assertEquals(actual_contents.splitlines(), expected_contents.splitlines()) + self.assertEqual(actual_contents.splitlines(), expected_contents.splitlines()) def test_set_short_description_and_bug_url(self): changelog_contents = u"%s\n%s" % (self._new_entry_boilerplate_with_bugurl, self._example_changelog) @@ -571,7 +571,7 @@ class ChangeLogTest(unittest.TestCase): expected_message = "%s\n %s" % (short_description, bug_url) expected_contents = changelog_contents.replace("Need a short description (OOPS!).", expected_message) os.remove(changelog_path) - self.assertEquals(actual_contents.splitlines(), expected_contents.splitlines()) + self.assertEqual(actual_contents.splitlines(), expected_contents.splitlines()) changelog_contents = u"%s\n%s" % (self._new_entry_boilerplate, self._example_changelog) changelog_path = self._write_tmp_file_with_contents(changelog_contents.encode("utf-8")) @@ -582,4 +582,4 @@ class ChangeLogTest(unittest.TestCase): expected_message = "%s\n %s" % (short_description, bug_url) expected_contents = changelog_contents.replace("Need a short description (OOPS!).\n Need the bug URL (OOPS!).", expected_message) os.remove(changelog_path) - self.assertEquals(actual_contents.splitlines(), expected_contents.splitlines()) + self.assertEqual(actual_contents.splitlines(), expected_contents.splitlines()) diff --git a/Tools/Scripts/webkitpy/common/checkout/diff_parser_unittest.py b/Tools/Scripts/webkitpy/common/checkout/diff_parser_unittest.py index d61a0989b..cba0f249e 100644 --- a/Tools/Scripts/webkitpy/common/checkout/diff_parser_unittest.py +++ b/Tools/Scripts/webkitpy/common/checkout/diff_parser_unittest.py @@ -36,44 +36,44 @@ class DiffParserTest(unittest.TestCase): def test_diff_parser(self, parser = None): if not parser: parser = diff_parser.DiffParser(DIFF_TEST_DATA.splitlines()) - self.assertEquals(3, len(parser.files)) + self.assertEqual(3, len(parser.files)) self.assertTrue('WebCore/rendering/style/StyleFlexibleBoxData.h' in parser.files) diff = parser.files['WebCore/rendering/style/StyleFlexibleBoxData.h'] - self.assertEquals(7, len(diff.lines)) + self.assertEqual(7, len(diff.lines)) # The first two unchaged lines. - self.assertEquals((47, 47), diff.lines[0][0:2]) - self.assertEquals('', diff.lines[0][2]) - self.assertEquals((48, 48), diff.lines[1][0:2]) - self.assertEquals(' unsigned align : 3; // EBoxAlignment', diff.lines[1][2]) + self.assertEqual((47, 47), diff.lines[0][0:2]) + self.assertEqual('', diff.lines[0][2]) + self.assertEqual((48, 48), diff.lines[1][0:2]) + self.assertEqual(' unsigned align : 3; // EBoxAlignment', diff.lines[1][2]) # The deleted line - self.assertEquals((50, 0), diff.lines[3][0:2]) - self.assertEquals(' unsigned orient: 1; // EBoxOrient', diff.lines[3][2]) + self.assertEqual((50, 0), diff.lines[3][0:2]) + self.assertEqual(' unsigned orient: 1; // EBoxOrient', diff.lines[3][2]) # The first file looks OK. Let's check the next, more complicated file. self.assertTrue('WebCore/rendering/style/StyleRareInheritedData.cpp' in parser.files) diff = parser.files['WebCore/rendering/style/StyleRareInheritedData.cpp'] # There are 3 chunks. - self.assertEquals(7 + 7 + 9, len(diff.lines)) + self.assertEqual(7 + 7 + 9, len(diff.lines)) # Around an added line. - self.assertEquals((60, 61), diff.lines[9][0:2]) - self.assertEquals((0, 62), diff.lines[10][0:2]) - self.assertEquals((61, 63), diff.lines[11][0:2]) + self.assertEqual((60, 61), diff.lines[9][0:2]) + self.assertEqual((0, 62), diff.lines[10][0:2]) + self.assertEqual((61, 63), diff.lines[11][0:2]) # Look through the last chunk, which contains both add's and delete's. - self.assertEquals((81, 83), diff.lines[14][0:2]) - self.assertEquals((82, 84), diff.lines[15][0:2]) - self.assertEquals((83, 85), diff.lines[16][0:2]) - self.assertEquals((84, 0), diff.lines[17][0:2]) - self.assertEquals((0, 86), diff.lines[18][0:2]) - self.assertEquals((0, 87), diff.lines[19][0:2]) - self.assertEquals((85, 88), diff.lines[20][0:2]) - self.assertEquals((86, 89), diff.lines[21][0:2]) - self.assertEquals((87, 90), diff.lines[22][0:2]) + self.assertEqual((81, 83), diff.lines[14][0:2]) + self.assertEqual((82, 84), diff.lines[15][0:2]) + self.assertEqual((83, 85), diff.lines[16][0:2]) + self.assertEqual((84, 0), diff.lines[17][0:2]) + self.assertEqual((0, 86), diff.lines[18][0:2]) + self.assertEqual((0, 87), diff.lines[19][0:2]) + self.assertEqual((85, 88), diff.lines[20][0:2]) + self.assertEqual((86, 89), diff.lines[21][0:2]) + self.assertEqual((87, 90), diff.lines[22][0:2]) # Check if a newly added file is correctly handled. diff = parser.files['LayoutTests/platform/mac/fast/flexbox/box-orient-button-expected.checksum'] - self.assertEquals(1, len(diff.lines)) - self.assertEquals((0, 1), diff.lines[0][0:2]) + self.assertEqual(1, len(diff.lines)) + self.assertEqual((0, 1), diff.lines[0][0:2]) def test_git_mnemonicprefix(self): p = re.compile(r' ([a|b])/') diff --git a/Tools/Scripts/webkitpy/common/checkout/scm/scm.py b/Tools/Scripts/webkitpy/common/checkout/scm/scm.py index 815e7501f..ee63b7130 100644 --- a/Tools/Scripts/webkitpy/common/checkout/scm/scm.py +++ b/Tools/Scripts/webkitpy/common/checkout/scm/scm.py @@ -137,7 +137,7 @@ class SCM: def in_working_directory(cls, path, executive=None): SCM._subclass_must_implement() - def find_checkout_root(path): + def find_checkout_root(self, path): SCM._subclass_must_implement() @staticmethod @@ -234,7 +234,7 @@ class SCM: def supports_local_commits(): SCM._subclass_must_implement() - def remote_merge_base(): + def remote_merge_base(self): SCM._subclass_must_implement() def commit_locally_with_message(self, message): diff --git a/Tools/Scripts/webkitpy/common/checkout/scm/scm_mock.py b/Tools/Scripts/webkitpy/common/checkout/scm/scm_mock.py index 9dd01e8d4..9c5d3af0d 100644 --- a/Tools/Scripts/webkitpy/common/checkout/scm/scm_mock.py +++ b/Tools/Scripts/webkitpy/common/checkout/scm/scm_mock.py @@ -26,6 +26,7 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +from webkitpy.common.checkout.scm import CommitMessage from webkitpy.common.system.filesystem_mock import MockFileSystem from webkitpy.common.system.executive_mock import MockExecutive diff --git a/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py b/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py index 802fe2cee..cff254e63 100644 --- a/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py +++ b/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py @@ -615,12 +615,12 @@ class SVNTest(SCMTest): self._setup_webkittools_scripts_symlink(self.scm) self.checkout.apply_patch(self._create_patch(one_line_overlap_patch)) expected_changelog_contents = "%s\n%s" % (self._set_date_and_reviewer(one_line_overlap_entry), changelog_contents) - self.assertEquals(read_from_path('ChangeLog'), expected_changelog_contents) + self.assertEqual(read_from_path('ChangeLog'), expected_changelog_contents) self.scm.revert_files(['ChangeLog']) self.checkout.apply_patch(self._create_patch(two_line_overlap_patch)) expected_changelog_contents = "%s\n%s" % (self._set_date_and_reviewer(two_line_overlap_entry), changelog_contents) - self.assertEquals(read_from_path('ChangeLog'), expected_changelog_contents) + self.assertEqual(read_from_path('ChangeLog'), expected_changelog_contents) def setUp(self): SVNTestRepository.setup(self) @@ -1192,7 +1192,7 @@ class GitSVNTest(SCMTest): def test_revisions_changing_files_with_local_commit(self): self._one_local_commit() - self.assertEquals(self.scm.revisions_changing_file('test_file_commit1'), []) + self.assertEqual(self.scm.revisions_changing_file('test_file_commit1'), []) def test_commit_with_message(self): self._one_local_commit_plus_working_copy_changes() @@ -1302,7 +1302,7 @@ class GitSVNTest(SCMTest): def test_upstream_branch(self): run_command(['git', 'checkout', '-t', '-b', 'my-branch']) run_command(['git', 'checkout', '-t', '-b', 'my-second-branch']) - self.assertEquals(self.scm._upstream_branch(), 'my-branch') + self.assertEqual(self.scm._upstream_branch(), 'my-branch') def test_remote_branch_ref(self): self.assertEqual(self.scm.remote_branch_ref(), 'refs/remotes/trunk') @@ -1353,7 +1353,7 @@ class GitSVNTest(SCMTest): os.remove('test_file_commit1') patch = scm.create_patch() patch_with_changed_files = scm.create_patch(changed_files=['test_file_commit1', 'test_file_commit2']) - self.assertEquals(patch, patch_with_changed_files) + self.assertEqual(patch, patch_with_changed_files) def test_create_patch_git_commit(self): self._two_local_commits() @@ -1597,7 +1597,7 @@ class GitTestWithMock(unittest.TestCase): OutputCapture().assert_outputs(self, scm.create_patch, expected_stderr=expected_stderr) def test_push_local_commits_to_server_with_username_and_password(self): - self.assertEquals(self.make_scm().push_local_commits_to_server(username='dbates@webkit.org', password='blah'), "MOCK output of child process") + self.assertEqual(self.make_scm().push_local_commits_to_server(username='dbates@webkit.org', password='blah'), "MOCK output of child process") def test_push_local_commits_to_server_without_username_and_password(self): self.assertRaises(AuthenticationError, self.make_scm().push_local_commits_to_server) diff --git a/Tools/Scripts/webkitpy/common/checkout/scm/svn.py b/Tools/Scripts/webkitpy/common/checkout/scm/svn.py index 25b7e3b47..112be057d 100644 --- a/Tools/Scripts/webkitpy/common/checkout/scm/svn.py +++ b/Tools/Scripts/webkitpy/common/checkout/scm/svn.py @@ -32,6 +32,7 @@ import os import re import shutil import sys +import tempfile from webkitpy.common.memoized import memoized from webkitpy.common.system.deprecated_logging import log @@ -46,6 +47,7 @@ _log = logging.getLogger(__name__) # A mixin class that represents common functionality for SVN and Git-SVN. class SVNRepository: def has_authorization_for_realm(self, realm, home_directory=os.getenv("HOME")): + # ignore false positives for methods implemented in the mixee class. pylint: disable-msg=E1101 # Assumes find and grep are installed. if not os.path.isdir(os.path.join(home_directory, ".subversion")): return False @@ -75,8 +77,7 @@ class SVN(SCM, SVNRepository): SCM.__init__(self, cwd, **kwargs) self._bogus_dir = None if patch_directories == []: - # FIXME: ScriptError is for Executive, this should probably be a normal Exception. - raise ScriptError(script_args=svn_info_args, message='Empty list of patch directories passed to SCM.__init__') + raise Exception(message='Empty list of patch directories passed to SCM.__init__') elif patch_directories == None: self._patch_directories = [self._filesystem.relpath(cwd, self.checkout_root)] else: diff --git a/Tools/Scripts/webkitpy/common/config/committers.py b/Tools/Scripts/webkitpy/common/config/committers.py index 36df3dbcc..ea92d9948 100644 --- a/Tools/Scripts/webkitpy/common/config/committers.py +++ b/Tools/Scripts/webkitpy/common/config/committers.py @@ -404,12 +404,13 @@ committers_unable_to_review = [ Committer("Victor Wang", "victorw@chromium.org", "victorw"), Committer("Victoria Kirst", ["vrk@chromium.org", "vrk@google.com"], "vrk"), Committer("Vincent Scheib", "scheib@chromium.org", "scheib"), + Committer("Vineet Chaudhary", "rgf748@motorola.com", "vineetc"), Committer("Vitaly Repeshko", "vitalyr@chromium.org"), Committer("William Siegrist", "wsiegrist@apple.com", "wms"), Committer("W. James MacLean", "wjmaclean@chromium.org", "seumas"), Committer("Xianzhu Wang", ["wangxianzhu@chromium.org", "phnixwxz@gmail.com", "wangxianzhu@google.com"], "wangxianzhu"), Committer("Xiaomei Ji", "xji@chromium.org", "xji"), - Committer("Yael Aharon", ["yael.aharon.m@gmail.com", "yael@webkit.org"], "yael"), + Committer("Yael Aharon", "yael@webkit.org", "yael"), Committer("Yaar Schnitman", ["yaar@chromium.org", "yaar@google.com"]), Committer("Yi Shen", ["yi.4.shen@nokia.com", "shenyi2006@gmail.com"]), Committer("Yongjun Zhang", ["yongjun.zhang@nokia.com", "yongjun_zhang@apple.com"]), @@ -444,7 +445,7 @@ reviewers_list = [ Reviewer("Alice Liu", "alice.liu@apple.com", "aliu"), Reviewer("Alp Toker", ["alp@nuanti.com", "alp@atoker.com", "alp@webkit.org"], "alp"), Reviewer("Anders Carlsson", ["andersca@apple.com", "acarlsson@apple.com"], "andersca"), - Reviewer("Andreas Kling", ["kling@webkit.org", "awesomekling@apple.com", "andreas.kling@nokia.com"], "kling"), + Reviewer("Andreas Kling", ["akling@apple.com", "kling@webkit.org", "awesomekling@apple.com", "andreas.kling@nokia.com"], "kling"), Reviewer("Andy Estes", "aestes@apple.com", "estes"), Reviewer("Antonio Gomes", ["tonikitoo@webkit.org", "agomes@rim.com"], "tonikitoo"), Reviewer("Antti Koivisto", ["koivisto@iki.fi", "antti@apple.com", "antti.j.koivisto@nokia.com"], "anttik"), @@ -523,7 +524,7 @@ reviewers_list = [ Reviewer("Mihai Parparita", "mihaip@chromium.org", "mihaip"), Reviewer("Nate Chapin", "japhet@chromium.org", ["japhet", "natechapin"]), Reviewer("Nikolas Zimmermann", ["zimmermann@kde.org", "zimmermann@physik.rwth-aachen.de", "zimmermann@webkit.org", "nzimmermann@rim.com"], "wildfox"), - Reviewer("Noam Rosenthal", "noam.rosenthal@nokia.com", "noamr"), + Reviewer("Noam Rosenthal", ["noam@webkit.org", "noam.rosenthal@nokia.com"], "noamr"), Reviewer("Ojan Vafai", "ojan@chromium.org", "ojan"), Reviewer("Oliver Hunt", "oliver@apple.com", "olliej"), Reviewer("Pavel Feldman", ["pfeldman@chromium.org", "pfeldman@google.com"], "pfeldman"), diff --git a/Tools/Scripts/webkitpy/common/config/contributionareas.py b/Tools/Scripts/webkitpy/common/config/contributionareas.py index 61a7488d6..b48df2a55 100644 --- a/Tools/Scripts/webkitpy/common/config/contributionareas.py +++ b/Tools/Scripts/webkitpy/common/config/contributionareas.py @@ -180,9 +180,6 @@ class ContributionAreas(object): def names(self): return [area.name() for area in self._contribution_areas] - def names(self): - return [area.name() for area in self._contribution_areas] - def _split_path(self, path): result = [] while path and len(path): diff --git a/Tools/Scripts/webkitpy/common/config/ports.py b/Tools/Scripts/webkitpy/common/config/ports.py index 884380e65..f6f3db0c8 100644 --- a/Tools/Scripts/webkitpy/common/config/ports.py +++ b/Tools/Scripts/webkitpy/common/config/ports.py @@ -38,6 +38,9 @@ from webkitpy.common.system.executive import Executive class DeprecatedPort(object): results_directory = "/tmp/layout-test-results" + # Subclasses must override + port_flag_name = None + # FIXME: This is only used by BotInfo. def name(self): return self.__class__ diff --git a/Tools/Scripts/webkitpy/common/config/ports_unittest.py b/Tools/Scripts/webkitpy/common/config/ports_unittest.py index 272052339..58d58d473 100644 --- a/Tools/Scripts/webkitpy/common/config/ports_unittest.py +++ b/Tools/Scripts/webkitpy/common/config/ports_unittest.py @@ -34,42 +34,42 @@ from webkitpy.common.config.ports import * class DeprecatedPortTest(unittest.TestCase): def test_mac_port(self): - self.assertEquals(MacPort().flag(), "--port=mac") - self.assertEquals(MacPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("run-webkit-tests")) - self.assertEquals(MacPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit")) - self.assertEquals(MacPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug"]) - self.assertEquals(MacPort().build_webkit_command(build_style="release"), DeprecatedPort().script_shell_command("build-webkit") + ["--release"]) + self.assertEqual(MacPort().flag(), "--port=mac") + self.assertEqual(MacPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("run-webkit-tests")) + self.assertEqual(MacPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit")) + self.assertEqual(MacPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug"]) + self.assertEqual(MacPort().build_webkit_command(build_style="release"), DeprecatedPort().script_shell_command("build-webkit") + ["--release"]) def test_gtk_port(self): - self.assertEquals(GtkPort().flag(), "--port=gtk") - self.assertEquals(GtkPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("run-webkit-tests") + ["--gtk"]) - self.assertEquals(GtkPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--gtk", "--update-gtk", DeprecatedPort().makeArgs()]) - self.assertEquals(GtkPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--gtk", "--update-gtk", DeprecatedPort().makeArgs()]) + self.assertEqual(GtkPort().flag(), "--port=gtk") + self.assertEqual(GtkPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("run-webkit-tests") + ["--gtk"]) + self.assertEqual(GtkPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--gtk", "--update-gtk", DeprecatedPort().makeArgs()]) + self.assertEqual(GtkPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--gtk", "--update-gtk", DeprecatedPort().makeArgs()]) def test_efl_port(self): - self.assertEquals(EflPort().flag(), "--port=efl") - self.assertEquals(EflPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--efl", "--update-efl", DeprecatedPort().makeArgs()]) - self.assertEquals(EflPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--efl", "--update-efl", DeprecatedPort().makeArgs()]) + self.assertEqual(EflPort().flag(), "--port=efl") + self.assertEqual(EflPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--efl", "--update-efl", DeprecatedPort().makeArgs()]) + self.assertEqual(EflPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--efl", "--update-efl", DeprecatedPort().makeArgs()]) def test_qt_port(self): - self.assertEquals(QtPort().flag(), "--port=qt") - self.assertEquals(QtPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("run-webkit-tests")) - self.assertEquals(QtPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--qt", DeprecatedPort().makeArgs()]) - self.assertEquals(QtPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--qt", DeprecatedPort().makeArgs()]) + self.assertEqual(QtPort().flag(), "--port=qt") + self.assertEqual(QtPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("run-webkit-tests")) + self.assertEqual(QtPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--qt", DeprecatedPort().makeArgs()]) + self.assertEqual(QtPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--qt", DeprecatedPort().makeArgs()]) def test_chromium_port(self): - self.assertEquals(ChromiumPort().flag(), "--port=chromium") - self.assertEquals(ChromiumPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("new-run-webkit-tests") + ["--chromium", "--skip-failing-tests"]) - self.assertEquals(ChromiumPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--chromium", "--update-chromium"]) - self.assertEquals(ChromiumPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--chromium", "--update-chromium"]) - self.assertEquals(ChromiumPort().update_webkit_command(), DeprecatedPort().script_shell_command("update-webkit") + ["--chromium"]) + self.assertEqual(ChromiumPort().flag(), "--port=chromium") + self.assertEqual(ChromiumPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("new-run-webkit-tests") + ["--chromium", "--skip-failing-tests"]) + self.assertEqual(ChromiumPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--chromium", "--update-chromium"]) + self.assertEqual(ChromiumPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--chromium", "--update-chromium"]) + self.assertEqual(ChromiumPort().update_webkit_command(), DeprecatedPort().script_shell_command("update-webkit") + ["--chromium"]) def test_chromium_android_port(self): - self.assertEquals(ChromiumAndroidPort().build_webkit_command(), ChromiumPort().build_webkit_command() + ["--chromium-android"]) - self.assertEquals(ChromiumAndroidPort().update_webkit_command(), ChromiumPort().update_webkit_command() + ["--chromium-android"]) + self.assertEqual(ChromiumAndroidPort().build_webkit_command(), ChromiumPort().build_webkit_command() + ["--chromium-android"]) + self.assertEqual(ChromiumAndroidPort().update_webkit_command(), ChromiumPort().update_webkit_command() + ["--chromium-android"]) def test_chromium_xvfb_port(self): - self.assertEquals(ChromiumXVFBPort().run_webkit_tests_command(), ['xvfb-run'] + DeprecatedPort().script_shell_command('new-run-webkit-tests') + ['--chromium', '--skip-failing-tests']) + self.assertEqual(ChromiumXVFBPort().run_webkit_tests_command(), ['xvfb-run'] + DeprecatedPort().script_shell_command('new-run-webkit-tests') + ['--chromium', '--skip-failing-tests']) if __name__ == '__main__': diff --git a/Tools/Scripts/webkitpy/common/config/urls_unittest.py b/Tools/Scripts/webkitpy/common/config/urls_unittest.py index 2b94b860e..b4bf8978a 100644 --- a/Tools/Scripts/webkitpy/common/config/urls_unittest.py +++ b/Tools/Scripts/webkitpy/common/config/urls_unittest.py @@ -34,28 +34,28 @@ from .urls import parse_bug_id, parse_attachment_id class URLsTest(unittest.TestCase): def test_parse_bug_id(self): # FIXME: These would be all better as doctests - self.assertEquals(12345, parse_bug_id("http://webkit.org/b/12345")) - self.assertEquals(12345, parse_bug_id("foo\n\nhttp://webkit.org/b/12345\nbar\n\n")) - self.assertEquals(12345, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?id=12345")) - self.assertEquals(12345, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?id=12345&ctype=xml")) - self.assertEquals(12345, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?id=12345&ctype=xml&excludefield=attachmentdata")) - self.assertEquals(12345, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?id=12345excludefield=attachmentdata&ctype=xml")) + self.assertEqual(12345, parse_bug_id("http://webkit.org/b/12345")) + self.assertEqual(12345, parse_bug_id("foo\n\nhttp://webkit.org/b/12345\nbar\n\n")) + self.assertEqual(12345, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?id=12345")) + self.assertEqual(12345, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?id=12345&ctype=xml")) + self.assertEqual(12345, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?id=12345&ctype=xml&excludefield=attachmentdata")) + self.assertEqual(12345, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?id=12345excludefield=attachmentdata&ctype=xml")) # Our url parser is super-fragile, but at least we're testing it. - self.assertEquals(None, parse_bug_id("http://www.webkit.org/b/12345")) - self.assertEquals(None, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?ctype=xml&id=12345")) - self.assertEquals(None, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?ctype=xml&id=12345&excludefield=attachmentdata")) - self.assertEquals(None, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?ctype=xml&excludefield=attachmentdata&id=12345")) - self.assertEquals(None, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?excludefield=attachmentdata&ctype=xml&id=12345")) - self.assertEquals(None, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?excludefield=attachmentdata&id=12345&ctype=xml")) + self.assertEqual(None, parse_bug_id("http://www.webkit.org/b/12345")) + self.assertEqual(None, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?ctype=xml&id=12345")) + self.assertEqual(None, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?ctype=xml&id=12345&excludefield=attachmentdata")) + self.assertEqual(None, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?ctype=xml&excludefield=attachmentdata&id=12345")) + self.assertEqual(None, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?excludefield=attachmentdata&ctype=xml&id=12345")) + self.assertEqual(None, parse_bug_id("http://bugs.webkit.org/show_bug.cgi?excludefield=attachmentdata&id=12345&ctype=xml")) def test_parse_attachment_id(self): - self.assertEquals(12345, parse_attachment_id("https://bugs.webkit.org/attachment.cgi?id=12345&action=review")) - self.assertEquals(12345, parse_attachment_id("https://bugs.webkit.org/attachment.cgi?id=12345&action=edit")) - self.assertEquals(12345, parse_attachment_id("https://bugs.webkit.org/attachment.cgi?id=12345&action=prettypatch")) - self.assertEquals(12345, parse_attachment_id("https://bugs.webkit.org/attachment.cgi?id=12345&action=diff")) + self.assertEqual(12345, parse_attachment_id("https://bugs.webkit.org/attachment.cgi?id=12345&action=review")) + self.assertEqual(12345, parse_attachment_id("https://bugs.webkit.org/attachment.cgi?id=12345&action=edit")) + self.assertEqual(12345, parse_attachment_id("https://bugs.webkit.org/attachment.cgi?id=12345&action=prettypatch")) + self.assertEqual(12345, parse_attachment_id("https://bugs.webkit.org/attachment.cgi?id=12345&action=diff")) # Direct attachment links are hosted from per-bug subdomains: - self.assertEquals(12345, parse_attachment_id("https://bug-23456-attachments.webkit.org/attachment.cgi?id=12345")) + self.assertEqual(12345, parse_attachment_id("https://bug-23456-attachments.webkit.org/attachment.cgi?id=12345")) # Make sure secure attachment URLs work too. - self.assertEquals(12345, parse_attachment_id("https://bug-23456-attachments.webkit.org/attachment.cgi?id=12345&t=Bqnsdkl9fs")) + self.assertEqual(12345, parse_attachment_id("https://bug-23456-attachments.webkit.org/attachment.cgi?id=12345&t=Bqnsdkl9fs")) diff --git a/Tools/Scripts/webkitpy/common/config/watchlist b/Tools/Scripts/webkitpy/common/config/watchlist index c3c9c9a2c..75f709b76 100755 --- a/Tools/Scripts/webkitpy/common/config/watchlist +++ b/Tools/Scripts/webkitpy/common/config/watchlist @@ -17,7 +17,11 @@ }, "ChromiumPublicApi": { "filename": r"Source/WebKit/chromium/public/" - r"|Source/Platform/chromium/public/", + r"|Source/Platform/chromium/public/" + r"|Tools/DumpRenderTree/chromium/TestRunner/public", + }, + "ChromiumTestRunner": { + "filename": r"Tools/DumpRenderTree/chromium/TestRunner", }, "AppleMacPublicApi": { "filename": r"Source/WebCore/bindings/objc/PublicDOMInterfaces.h" @@ -105,8 +109,7 @@ # Project files for each target are intentionally left out, as those # mostly list source and header files, which would just add noise. "filename": r"Tools/qmake/" - r"|WebKit.pro" - r"|.*DerivedSources\.pri", + r"|WebKit.pro", }, "QtWebKit2PublicAPI": { "filename": r"Source/WebKit2/UIProcess/API/qt/" @@ -115,8 +118,12 @@ }, "QtGraphics": { "filename": r"Source/WebCore/platform/graphics/qt/" - r"|Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/" - r"|Source/WebKit2/UIProcess/CoordinatedGraphics", + }, + "CoordinatedGraphics": { + "filename": r"Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/" + r"|Source/WebKit2/UIProcess/CoordinatedGraphics/" + r"|Source/WebKit2/Shared/CoordinatedGraphics/" + r"|Source/WebCore/platform/graphics/surfaces/", }, "TextureMapper": { "filename": r"Source/WebCore/platform/graphics/texmap/", @@ -147,6 +154,12 @@ "CSS": { "filename": r"Source/WebCore/css/", }, + "DOM": { + "filename": r"Source/WebCore/dom/", + }, + "HTML": { + "filename": r"Source/WebCore/html/", + }, "DOMAttributes": { "filename": r"Source/WebCore/dom/.*Attr.*" r"|Source/WebCore/dom/NamedNodeMap\.(cpp|h|idl)" @@ -293,9 +306,12 @@ "BlackBerry": [ "mifenton@rim.com", "rwlbuis@gmail.com", "tonikitoo@webkit.org" ], "Cairo": [ "dominik.rottsches@intel.com" ], "CMake": [ "rakuco@webkit.org", "gyuyoung.kim@samsung.com" ], - "CSS": [ "alexis@webkit.org", "macpherson@chromium.org", "cmarcelo@webkit.org"], + "CoordinatedGraphics" : [ "noam@webkit.org", "zeno@webkit.org" ], + "CSS": [ "alexis@webkit.org", "macpherson@chromium.org", "cmarcelo@webkit.org", "ojan@chromium.org"], "ChromiumGraphics": [ "jamesr@chromium.org", "cc-bugs@chromium.org" ], "ChromiumPublicApi": [ "abarth@webkit.org", "dglazkov@chromium.org", "fishd@chromium.org", "jamesr@chromium.org", "tkent+wkapi@chromium.org" ], + "ChromiumTestRunner": [ "jochen@chromium.org" ], + "DOM": [ "ojan@chromium.org" ], "DOMAttributes": [ "cmarcelo@webkit.org", ], "EFL": [ "rakuco@webkit.org", "gyuyoung.kim@samsung.com" ], "EFLWebKit2PlatformSpecific": [ "gyuyoung.kim@samsung.com", "rakuco@webkit.org" ], @@ -307,17 +323,18 @@ "GStreamerGraphics": [ "alexis@webkit.org", "pnormand@igalia.com", "gns@gnome.org", "mrobinson@webkit.org" ], "GtkWebKit2PublicAPI": [ "cgarcia@igalia.com", "gns@gnome.org", "mrobinson@webkit.org" ], "Harfbuzz": [ "dominik.rottsches@intel.com" ], + "HTML": [ "ojan@chromium.org" ], "Loader": [ "japhet@chromium.org" ], "MathML": [ "dbarton@mathscribe.com" ], "Media": [ "feature-media-reviews@chromium.org", "eric.carlson@apple.com" ], "MediaStream": [ "tommyw@google.com", "hta@google.com" ], "NetworkInfo": [ "gyuyoung.kim@samsung.com" ], - "OpenGL" : [ "noam.rosenthal@nokia.com", "dino@apple.com" ], + "OpenGL" : [ "noam@webkit.org", "dino@apple.com" ], "QtBuildSystem" : [ "vestbo@webkit.org", "abecsi@webkit.org" ], - "QtGraphics" : [ "noam.rosenthal@nokia.com" ], + "QtGraphics" : [ "noam@webkit.org" ], "QtWebKit2PlatformSpecific": [ "alexis@webkit.org", "cmarcelo@webkit.org", "abecsi@webkit.org" ], "QtWebKit2PublicAPI": [ "alexis@webkit.org", "cmarcelo@webkit.org", "abecsi@webkit.org" ], - "Rendering": [ "eric@webkit.org" ], + "Rendering": [ "eric@webkit.org", "ojan@chromium.org" ], "SVG": ["schenney@chromium.org", "pdr@google.com", "fmalita@chromium.org", "dominik.rottsches@intel.com" ], "SVNScripts": [ "dbates@webkit.org" ], "ScrollingCoordinator": [ "andersca@apple.com", "jamesr@chromium.org", "tonikitoo@webkit.org" ], @@ -326,21 +343,21 @@ "Selectors": [ "allan.jensen@digia.com" ], "SoupNetwork": [ "rakuco@webkit.org", "gns@gnome.org", "mrobinson@webkit.org", "danw@gnome.org" ], "StyleChecker": [ "levin@chromium.org", ], - "TestFailures": [ "abarth@webkit.org", "dglazkov@chromium.org" ], - "TextureMapper" : [ "noam.rosenthal@nokia.com" ], + "TestFailures": [ "abarth@webkit.org", "dglazkov@chromium.org", "ojan@chromium.org" ], + "TextureMapper" : [ "noam@webkit.org" ], "ThreadingFiles|ThreadingUsage": [ "levin+threading@chromium.org", ], "TouchAdjustment" : [ "allan.jensen@digia.com" ], "V8Bindings|BindingsScripts": [ "abarth@webkit.org", "japhet@chromium.org", "haraken@chromium.org" ], - "WTF": [ "benjamin@webkit.org",], + "WTF": [ "benjamin@webkit.org", "ojan@chromium.org"], "WatchListScript": [ "levin+watchlist@chromium.org", ], "WebGL": [ "dino@apple.com" ], "WebIDL": [ "abarth@webkit.org", "ojan@chromium.org" ], "WebInspectorAPI": [ "timothy@apple.com", "joepeck@webkit.org" ], "WebKitGTKTranslations": [ "gns@gnome.org", "mrobinson@webkit.org" ], "WebSocket": [ "yutak@chromium.org" ], - "XSS": [ "dbates@webkit.org" ], + "XSS": [ "dbates@webkit.org", "ojan@chromium.org" ], "webkitperl": [ "dbates@webkit.org" ], - "webkitpy": [ "abarth@webkit.org", "ojan@chromium.org", "dpranke@chromium.org" ], + "webkitpy": [ "abarth@webkit.org", "dpranke@chromium.org" ], }, "MESSAGE_RULES": { "ChromiumPublicApi": [ "Please wait for approval from abarth@webkit.org, dglazkov@chromium.org, " diff --git a/Tools/Scripts/webkitpy/common/find_files_unittest.py b/Tools/Scripts/webkitpy/common/find_files_unittest.py index 75beaf0b4..641251f0e 100644 --- a/Tools/Scripts/webkitpy/common/find_files_unittest.py +++ b/Tools/Scripts/webkitpy/common/find_files_unittest.py @@ -43,7 +43,7 @@ class MockWinFileSystem(object): class TestWinNormalize(unittest.TestCase): def assert_filesystem_normalizes(self, filesystem): - self.assertEquals(find_files._normalize(filesystem, "c:\\foo", + self.assertEqual(find_files._normalize(filesystem, "c:\\foo", ['fast/html', 'fast/canvas/*', 'compositing/foo.html']), ['c:\\foo\\fast\html', 'c:\\foo\\fast\canvas\*', 'c:\\foo\compositing\\foo.html']) diff --git a/Tools/Scripts/webkitpy/common/net/bugzilla/bugzilla_unittest.py b/Tools/Scripts/webkitpy/common/net/bugzilla/bugzilla_unittest.py index 6108b5e8a..538d39e85 100644 --- a/Tools/Scripts/webkitpy/common/net/bugzilla/bugzilla_unittest.py +++ b/Tools/Scripts/webkitpy/common/net/bugzilla/bugzilla_unittest.py @@ -85,16 +85,16 @@ class BugzillaTest(unittest.TestCase): def test_url_creation(self): # FIXME: These would be all better as doctests bugs = Bugzilla() - self.assertEquals(None, bugs.bug_url_for_bug_id(None)) - self.assertEquals(None, bugs.short_bug_url_for_bug_id(None)) - self.assertEquals(None, bugs.attachment_url_for_id(None)) + self.assertEqual(None, bugs.bug_url_for_bug_id(None)) + self.assertEqual(None, bugs.short_bug_url_for_bug_id(None)) + self.assertEqual(None, bugs.attachment_url_for_id(None)) def test_parse_bug_id(self): # Test that we can parse the urls we produce. bugs = Bugzilla() - self.assertEquals(12345, urls.parse_bug_id(bugs.short_bug_url_for_bug_id(12345))) - self.assertEquals(12345, urls.parse_bug_id(bugs.bug_url_for_bug_id(12345))) - self.assertEquals(12345, urls.parse_bug_id(bugs.bug_url_for_bug_id(12345, xml=True))) + self.assertEqual(12345, urls.parse_bug_id(bugs.short_bug_url_for_bug_id(12345))) + self.assertEqual(12345, urls.parse_bug_id(bugs.bug_url_for_bug_id(12345))) + self.assertEqual(12345, urls.parse_bug_id(bugs.bug_url_for_bug_id(12345, xml=True))) _bug_xml = """ <bug> @@ -198,10 +198,10 @@ Ignore this bug. Just for testing failure modes of webkit-patch and the commit- # FIXME: This should move to a central location and be shared by more unit tests. def _assert_dictionaries_equal(self, actual, expected): # Make sure we aren't parsing more or less than we expect - self.assertEquals(sorted(actual.keys()), sorted(expected.keys())) + self.assertEqual(sorted(actual.keys()), sorted(expected.keys())) for key, expected_value in expected.items(): - self.assertEquals(actual[key], expected_value, ("Failure for key: %s: Actual='%s' Expected='%s'" % (key, actual[key], expected_value))) + self.assertEqual(actual[key], expected_value, ("Failure for key: %s: Actual='%s' Expected='%s'" % (key, actual[key], expected_value))) def test_parse_bug_dictionary_from_xml(self): bug = Bugzilla()._parse_bug_dictionary_from_xml(self._single_bug_xml) @@ -217,10 +217,10 @@ Ignore this bug. Just for testing failure modes of webkit-patch and the commit- def test_parse_bugs_from_xml(self): bugzilla = Bugzilla() bugs = bugzilla._parse_bugs_from_xml(self._sample_multi_bug_xml) - self.assertEquals(len(bugs), 2) - self.assertEquals(bugs[0].id(), self._expected_example_bug_parsing['id']) + self.assertEqual(len(bugs), 2) + self.assertEqual(bugs[0].id(), self._expected_example_bug_parsing['id']) bugs = bugzilla._parse_bugs_from_xml("") - self.assertEquals(len(bugs), 0) + self.assertEqual(len(bugs), 0) # This could be combined into test_bug_parsing later if desired. def test_attachment_parsing(self): @@ -244,7 +244,7 @@ Ignore this bug. Just for testing failure modes of webkit-patch and the commit- def test_attachment_detail_bug_parsing(self): bugzilla = Bugzilla() - self.assertEquals(27314, bugzilla._parse_bug_id_from_attachment_page(self._sample_attachment_detail_page)) + self.assertEqual(27314, bugzilla._parse_bug_id_from_attachment_page(self._sample_attachment_detail_page)) def test_add_cc_to_bug(self): bugzilla = Bugzilla() @@ -408,7 +408,7 @@ class BugzillaQueriesTest(unittest.TestCase): """ def _assert_result_count(self, queries, html, count): - self.assertEquals(queries._parse_result_count(html), count) + self.assertEqual(queries._parse_result_count(html), count) def test_parse_result_count(self): queries = BugzillaQueries(None) @@ -420,12 +420,12 @@ class BugzillaQueriesTest(unittest.TestCase): def test_request_page_parsing(self): queries = BugzillaQueries(None) - self.assertEquals([40511, 40722, 40723], queries._parse_attachment_ids_request_query(self._sample_request_page)) + self.assertEqual([40511, 40722, 40723], queries._parse_attachment_ids_request_query(self._sample_request_page)) def test_quip_page_parsing(self): queries = BugzillaQueries(None) expected_quips = ["Everything should be made as simple as possible, but not simpler. - Albert Einstein", "Good artists copy. Great artists steal. - Pablo Picasso", u"\u00e7gua mole em pedra dura, tanto bate at\u008e que fura."] - self.assertEquals(expected_quips, queries._parse_quips(self._sample_quip_page)) + self.assertEqual(expected_quips, queries._parse_quips(self._sample_quip_page)) def test_load_query(self): queries = BugzillaQueries(Mock()) @@ -482,7 +482,7 @@ class EditUsersParserTest(unittest.TestCase): def _assert_login_userid_pairs(self, results_page, expected_logins): parser = EditUsersParser() logins = parser.login_userid_pairs_from_edit_user_results(results_page) - self.assertEquals(logins, expected_logins) + self.assertEqual(logins, expected_logins) def test_logins_from_editusers_results(self): self._assert_login_userid_pairs(self._example_user_results, [("abarth@webkit.org", 1234)]) diff --git a/Tools/Scripts/webkitpy/common/net/buildbot/buildbot.py b/Tools/Scripts/webkitpy/common/net/buildbot/buildbot.py index adb5a3d2c..d6804d5b7 100644 --- a/Tools/Scripts/webkitpy/common/net/buildbot/buildbot.py +++ b/Tools/Scripts/webkitpy/common/net/buildbot/buildbot.py @@ -135,6 +135,7 @@ class Builder(object): return form.find_control("username") except Exception, e: return False + # ignore false positives for missing Browser methods - pylint: disable-msg=E1102 self._browser.open(self.url()) self._browser.select_form(predicate=predicate) self._browser["username"] = username diff --git a/Tools/Scripts/webkitpy/common/net/buildbot/buildbot_mock.py b/Tools/Scripts/webkitpy/common/net/buildbot/buildbot_mock.py index f8ec49b7b..f5b6042b3 100644 --- a/Tools/Scripts/webkitpy/common/net/buildbot/buildbot_mock.py +++ b/Tools/Scripts/webkitpy/common/net/buildbot/buildbot_mock.py @@ -26,6 +26,8 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +from webkitpy.common.system.deprecated_logging import log + class MockBuild(object): def __init__(self, build_number, revision, is_green): diff --git a/Tools/Scripts/webkitpy/common/net/buildbot/buildbot_unittest.py b/Tools/Scripts/webkitpy/common/net/buildbot/buildbot_unittest.py index 69f864889..547a8e6ff 100644 --- a/Tools/Scripts/webkitpy/common/net/buildbot/buildbot_unittest.py +++ b/Tools/Scripts/webkitpy/common/net/buildbot/buildbot_unittest.py @@ -232,10 +232,10 @@ class BuildBotTest(unittest.TestCase): builder = buildbot._parse_builder_status_from_row(status_row) # Make sure we aren't parsing more or less than we expect - self.assertEquals(builder.keys(), expected_parsing.keys()) + self.assertEqual(builder.keys(), expected_parsing.keys()) for key, expected_value in expected_parsing.items(): - self.assertEquals(builder[key], expected_value, ("Builder %d parse failure for key: %s: Actual='%s' Expected='%s'" % (x, key, builder[key], expected_value))) + self.assertEqual(builder[key], expected_value, ("Builder %d parse failure for key: %s: Actual='%s' Expected='%s'" % (x, key, builder[key], expected_value))) def test_builder_with_name(self): buildbot = BuildBot() @@ -464,7 +464,7 @@ class BuildBotTest(unittest.TestCase): b = Builder('builder', BuildBot()) b._fetch_build = self._fetch_build b._fetch_revision_to_build_map = self._fetch_revision_to_build_map - self.assertEquals("correct build", b.latest_cached_build()) + self.assertEqual("correct build", b.latest_cached_build()) def results_url(self): return "some-url" @@ -472,7 +472,7 @@ class BuildBotTest(unittest.TestCase): def test_results_zip_url(self): b = Build(None, 123, 123, False) b.results_url = self.results_url - self.assertEquals("some-url.zip", b.results_zip_url()) + self.assertEqual("some-url.zip", b.results_zip_url()) if __name__ == '__main__': diff --git a/Tools/Scripts/webkitpy/common/net/credentials_unittest.py b/Tools/Scripts/webkitpy/common/net/credentials_unittest.py index a797e3d1b..15682f3b8 100644 --- a/Tools/Scripts/webkitpy/common/net/credentials_unittest.py +++ b/Tools/Scripts/webkitpy/common/net/credentials_unittest.py @@ -135,8 +135,8 @@ password: "SECRETSAUCE" os.environ['WEBKIT_BUGZILLA_USERNAME'] = "foo" os.environ['WEBKIT_BUGZILLA_PASSWORD'] = "bar" username, password = credentials._credentials_from_environment() - self.assertEquals(username, "foo") - self.assertEquals(password, "bar") + self.assertEqual(username, "foo") + self.assertEqual(password, "bar") os.environ = saved_environ def test_read_credentials_without_git_repo(self): diff --git a/Tools/Scripts/webkitpy/common/net/failuremap_unittest.py b/Tools/Scripts/webkitpy/common/net/failuremap_unittest.py index 9a66d9ede..bd41032cb 100644 --- a/Tools/Scripts/webkitpy/common/net/failuremap_unittest.py +++ b/Tools/Scripts/webkitpy/common/net/failuremap_unittest.py @@ -54,27 +54,27 @@ class FailureMapTest(unittest.TestCase): def test_failing_revisions(self): failure_map = self._make_failure_map() - self.assertEquals(failure_map.failing_revisions(), [1234, 1235]) + self.assertEqual(failure_map.failing_revisions(), [1234, 1235]) def test_new_failures(self): failure_map = self._make_failure_map() failure_map.filter_out_old_failures(lambda revision: False) - self.assertEquals(failure_map.failing_revisions(), [1234, 1235]) + self.assertEqual(failure_map.failing_revisions(), [1234, 1235]) def test_new_failures_with_old_revisions(self): failure_map = self._make_failure_map() failure_map.filter_out_old_failures(lambda revision: revision == 1234) - self.assertEquals(failure_map.failing_revisions(), []) + self.assertEqual(failure_map.failing_revisions(), []) def test_new_failures_with_more_old_revisions(self): failure_map = self._make_failure_map() failure_map.filter_out_old_failures(lambda revision: revision == 1235) - self.assertEquals(failure_map.failing_revisions(), [1234]) + self.assertEqual(failure_map.failing_revisions(), [1234]) def test_tests_failing_for(self): failure_map = self._make_failure_map() - self.assertEquals(failure_map.tests_failing_for(1234), [u'test1']) + self.assertEqual(failure_map.tests_failing_for(1234), [u'test1']) def test_failing_tests(self): failure_map = self._make_failure_map() - self.assertEquals(failure_map.failing_tests(), set([u'test1'])) + self.assertEqual(failure_map.failing_tests(), set([u'test1'])) diff --git a/Tools/Scripts/webkitpy/common/net/layouttestresults_unittest.py b/Tools/Scripts/webkitpy/common/net/layouttestresults_unittest.py index 939a56a7d..462a88c66 100644 --- a/Tools/Scripts/webkitpy/common/net/layouttestresults_unittest.py +++ b/Tools/Scripts/webkitpy/common/net/layouttestresults_unittest.py @@ -130,9 +130,9 @@ class LayoutTestResultsTest(unittest.TestCase): def test_set_failure_limit_count(self): results = LayoutTestResults([]) - self.assertEquals(results.failure_limit_count(), None) + self.assertEqual(results.failure_limit_count(), None) results.set_failure_limit_count(10) - self.assertEquals(results.failure_limit_count(), 10) + self.assertEqual(results.failure_limit_count(), 10) def test_results_from_string(self): self.assertEqual(LayoutTestResults.results_from_string(None), None) diff --git a/Tools/Scripts/webkitpy/common/net/unittestresults_unittest.py b/Tools/Scripts/webkitpy/common/net/unittestresults_unittest.py index f8852062c..40e80236f 100644 --- a/Tools/Scripts/webkitpy/common/net/unittestresults_unittest.py +++ b/Tools/Scripts/webkitpy/common/net/unittestresults_unittest.py @@ -34,10 +34,10 @@ from unittestresults import UnitTestResults class UnitTestResultsTest(unittest.TestCase): def test_nostring(self): - self.assertEquals(None, UnitTestResults.results_from_string(None)) + self.assertEqual(None, UnitTestResults.results_from_string(None)) def test_emptystring(self): - self.assertEquals(None, UnitTestResults.results_from_string("")) + self.assertEqual(None, UnitTestResults.results_from_string("")) def test_nofailures(self): no_failures_xml = """<?xml version="1.0" encoding="UTF-8"?> @@ -48,7 +48,7 @@ class UnitTestResultsTest(unittest.TestCase): <testcase name="CrashIfSettingUnsetRowIndex" status="run" time="0.123" classname="RenderTableCellDeathTest" /> </testsuite> </testsuites>""" - self.assertEquals([], UnitTestResults.results_from_string(no_failures_xml)) + self.assertEqual([], UnitTestResults.results_from_string(no_failures_xml)) def test_onefailure(self): one_failure_xml = """<?xml version="1.0" encoding="UTF-8"?> @@ -66,7 +66,7 @@ Expected: 1]]></failure> </testsuite> </testsuites>""" expected = ["WebFrameTest.FAILS_DivAutoZoomParamsTest"] - self.assertEquals(expected, UnitTestResults.results_from_string(one_failure_xml)) + self.assertEqual(expected, UnitTestResults.results_from_string(one_failure_xml)) def test_multiple_failures_per_test(self): multiple_failures_per_test_xml = """<?xml version="1.0" encoding="UTF-8"?> @@ -91,7 +91,7 @@ Expected: 6.28]]></failure> </testsuite> </testsuites>""" expected = ["ClassOne.TestOne", "ClassTwo.TestTwo"] - self.assertEquals(expected, UnitTestResults.results_from_string(multiple_failures_per_test_xml)) + self.assertEqual(expected, UnitTestResults.results_from_string(multiple_failures_per_test_xml)) if __name__ == '__main__': diff --git a/Tools/Scripts/webkitpy/common/newstringio.py b/Tools/Scripts/webkitpy/common/newstringio.py index f6d08ec59..724fb11aa 100644 --- a/Tools/Scripts/webkitpy/common/newstringio.py +++ b/Tools/Scripts/webkitpy/common/newstringio.py @@ -29,10 +29,10 @@ """'with'-compliant StringIO implementation.""" -import StringIO +import StringIO as OldStringIO -class StringIO(StringIO.StringIO): +class StringIO(OldStringIO.StringIO): def __enter__(self): return self diff --git a/Tools/Scripts/webkitpy/common/read_checksum_from_png_unittest.py b/Tools/Scripts/webkitpy/common/read_checksum_from_png_unittest.py index defbbf806..a56bec2e4 100644 --- a/Tools/Scripts/webkitpy/common/read_checksum_from_png_unittest.py +++ b/Tools/Scripts/webkitpy/common/read_checksum_from_png_unittest.py @@ -32,12 +32,12 @@ class ReadChecksumFromPngTest(unittest.TestCase): # Test a file with the comment. filehandle = StringIO.StringIO('''\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x03 \x00\x00\x02X\x08\x02\x00\x00\x00\x15\x14\x15'\x00\x00\x00)tEXtchecksum\x003c4134fe2739880353f91c5b84cadbaaC\xb8?\xec\x00\x00\x16\xfeIDATx\x9c\xed\xdd[\x8cU\xe5\xc1\xff\xf15T\x18\x0ea,)\xa6\x80XZ<\x10\n\xd6H\xc4V\x88}\xb5\xa9\xd6r\xd5\x0bki0\xa6\xb5ih\xd2\xde\x98PHz\xd1\x02=\\q#\x01\x8b\xa5rJ\x8b\x88i\xacM\xc5h\x8cbMk(\x1ez@!\x0c\xd5\xd2\xc2\xb44\x1c\x848\x1dF(\xeb\x7f\xb1\xff\xd9\xef~g\xd6\xde3\xe0o\x10\xec\xe7sa6{\xd6z\xd6\xb3\xd7\xf3\xa8_7\xdbM[Y\x96\x05\x00\x009\xc3\xde\xeb\t\x00\x00\xbc\xdf\x08,\x00\x800\x81\x05\x00\x10&\xb0\x00\x00\xc2\x04\x16\x00@\x98\xc0\x02\x00\x08\x13X\x00\x00a\x02\x0b\x00 L x01\x00\x84\t,\x00\x800\x81\x05\x00\x10\xd64\xb0\xda\x9a\xdb\xb6m\xdb\xb4i\xd3\xfa\x9fr\xf3\xcd7\x0f\xe5T\x07\xe5\xd4\xa9''') checksum = read_checksum_from_png.read_checksum(filehandle) - self.assertEquals('3c4134fe2739880353f91c5b84cadbaa', checksum) + self.assertEqual('3c4134fe2739880353f91c5b84cadbaa', checksum) # Test a file without the comment. filehandle = StringIO.StringIO('''\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x03 \x00\x00\x02X\x08\x02\x00\x00\x00\x15\x14\x15'\x00\x00\x16\xfeIDATx\x9c\xed\xdd[\x8cU\xe5\xc1\xff\xf15T\x18\x0ea,)\xa6\x80XZ<\x10\n\xd6H\xc4V\x88}\xb5\xa9\xd6r\xd5\x0bki0\xa6\xb5ih\xd2\xde\x98PHz\xd1\x02=\\q#\x01\x8b\xa5rJ\x8b\x88i\xacM\xc5h\x8cbMk(\x1ez@!\x0c\xd5\xd2\xc2\xb44\x1c\x848\x1dF(\xeb\x7f\xb1\xff\xd9\xef~g\xd6\xde3\xe0o\x10\xec\xe7sa6{\xd6z\xd6\xb3\xd7\xf3\xa8_7\xdbM[Y\x96\x05\x00\x009\xc3\xde\xeb\t\x00\x00\xbc\xdf\x08,\x00\x800\x81\x05\x00\x10&\xb0\x00\x00\xc2\x04\x16\x00@\x98\xc0\x02\x00\x08\x13X\x00\x00a\x02\x0b\x00 L x01\x00\x84\t,\x00\x800\x81\x05\x00\x10\xd64\xb0\xda\x9a\xdb\xb6m\xdb\xb4i\xd3\xfa\x9fr\xf3\xcd7\x0f\xe5T\x07\xe5\xd4\xa9S\x8b\x17/\x1e?~\xfc\xf8\xf1\xe3\xef\xbf\xff\xfe\xf7z:M5\xbb\x87\x17\xcbUZ\x8f|V\xd7\xbd\x10\xb6\xcd{b\x88\xf6j\xb3\x9b?\x14\x9b\xa1>\xe6\xf9\xd9\xcf\x00\x17\x93''') checksum = read_checksum_from_png.read_checksum(filehandle) - self.assertEquals(None, checksum) + self.assertEqual(None, checksum) if __name__ == '__main__': diff --git a/Tools/Scripts/webkitpy/common/system/deprecated_logging_unittest.py b/Tools/Scripts/webkitpy/common/system/deprecated_logging_unittest.py index 377816207..b986609bb 100644 --- a/Tools/Scripts/webkitpy/common/system/deprecated_logging_unittest.py +++ b/Tools/Scripts/webkitpy/common/system/deprecated_logging_unittest.py @@ -47,7 +47,7 @@ class LoggingTest(unittest.TestCase): finally: sys.stderr = original_stderr - self.assertEquals(actual_output, expected_output, "log(\"%s\") expected: %s actual: %s" % (log_input, expected_output, actual_output)) + self.assertEqual(actual_output, expected_output, "log(\"%s\") expected: %s actual: %s" % (log_input, expected_output, actual_output)) def test_log(self): self.assert_log_equals("test", "test\n") diff --git a/Tools/Scripts/webkitpy/common/system/executive_mock.py b/Tools/Scripts/webkitpy/common/system/executive_mock.py index c2613530b..47eddea8b 100644 --- a/Tools/Scripts/webkitpy/common/system/executive_mock.py +++ b/Tools/Scripts/webkitpy/common/system/executive_mock.py @@ -168,7 +168,7 @@ class MockExecutive2(MockExecutive): self.calls.append(args) assert(isinstance(args, list) or isinstance(args, tuple)) if self._exception: - raise self._exception + raise self._exception # pylint: disable-msg=E0702 if self._run_command_fn: return self._run_command_fn(args) if return_exit_code: diff --git a/Tools/Scripts/webkitpy/common/system/executive_unittest.py b/Tools/Scripts/webkitpy/common/system/executive_unittest.py index 57c557369..755955d34 100644 --- a/Tools/Scripts/webkitpy/common/system/executive_unittest.py +++ b/Tools/Scripts/webkitpy/common/system/executive_unittest.py @@ -48,19 +48,19 @@ from webkitpy.common.system.filesystem_mock import MockFileSystem class ScriptErrorTest(unittest.TestCase): def test_string_from_args(self): error = ScriptError() - self.assertEquals(error._string_from_args(None), 'None') - self.assertEquals(error._string_from_args([]), '[]') - self.assertEquals(error._string_from_args(map(str, range(30))), "['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17'...") + self.assertEqual(error._string_from_args(None), 'None') + self.assertEqual(error._string_from_args([]), '[]') + self.assertEqual(error._string_from_args(map(str, range(30))), "['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17'...") def test_message_with_output(self): error = ScriptError('My custom message!', '', -1) - self.assertEquals(error.message_with_output(), 'My custom message!') + self.assertEqual(error.message_with_output(), 'My custom message!') error = ScriptError('My custom message!', '', -1, 'My output.') - self.assertEquals(error.message_with_output(), 'My custom message!\n\nMy output.') + self.assertEqual(error.message_with_output(), 'My custom message!\n\nMy output.') error = ScriptError('', 'my_command!', -1, 'My output.', '/Users/username/blah') - self.assertEquals(error.message_with_output(), 'Failed to run "my_command!" exit_code: -1 cwd: /Users/username/blah\n\nMy output.') + self.assertEqual(error.message_with_output(), 'Failed to run "my_command!" exit_code: -1 cwd: /Users/username/blah\n\nMy output.') error = ScriptError('', 'my_command!', -1, 'ab' + '1' * 499) - self.assertEquals(error.message_with_output(), 'Failed to run "my_command!" exit_code: -1\n\nLast 500 characters of output:\nb' + '1' * 499) + self.assertEqual(error.message_with_output(), 'Failed to run "my_command!" exit_code: -1\n\nLast 500 characters of output:\nb' + '1' * 499) def never_ending_command(): """Arguments for a command that will never end (useful for testing process @@ -104,7 +104,7 @@ class ExecutiveTest(unittest.TestCase): def test_run_command_with_bad_command(self): def run_bad_command(): Executive().run_command(["foo_bar_command_blah"], error_handler=Executive.ignore_error, return_exit_code=True) - self.failUnlessRaises(OSError, run_bad_command) + self.assertRaises(OSError, run_bad_command) def test_run_command_args_type(self): executive = Executive() @@ -133,24 +133,24 @@ class ExecutiveTest(unittest.TestCase): executive = Executive() output = executive.run_command(command_line('cat'), input=unicode_tor_input) - self.assertEquals(output, unicode_tor_output) + self.assertEqual(output, unicode_tor_output) output = executive.run_command(command_line('echo', unicode_tor_input)) - self.assertEquals(output, unicode_tor_output) + self.assertEqual(output, unicode_tor_output) output = executive.run_command(command_line('echo', unicode_tor_input), decode_output=False) - self.assertEquals(output, encoded_tor) + self.assertEqual(output, encoded_tor) # Make sure that str() input also works. output = executive.run_command(command_line('cat'), input=encoded_tor, decode_output=False) - self.assertEquals(output, encoded_tor) + self.assertEqual(output, encoded_tor) # FIXME: We should only have one run* method to test output = executive.run_and_throw_if_fail(command_line('echo', unicode_tor_input), quiet=True) - self.assertEquals(output, unicode_tor_output) + self.assertEqual(output, unicode_tor_output) output = executive.run_and_throw_if_fail(command_line('echo', unicode_tor_input), quiet=True, decode_output=False) - self.assertEquals(output, encoded_tor) + self.assertEqual(output, encoded_tor) def serial_test_kill_process(self): executive = Executive() @@ -236,8 +236,8 @@ class ExecutiveTest(unittest.TestCase): command_outputs = Executive().run_in_parallel(commands, processes=NUM_PROCESSES) done = time.time() self.assertTrue(done - start < NUM_PROCESSES * DELAY_SECS) - self.assertEquals([output[1] for output in command_outputs], ["hello\n"] * NUM_PROCESSES) - self.assertEquals([], multiprocessing.active_children()) + self.assertEqual([output[1] for output in command_outputs], ["hello\n"] * NUM_PROCESSES) + self.assertEqual([], multiprocessing.active_children()) def test_run_in_parallel_assert_nonempty(self): self.assertRaises(AssertionError, Executive().run_in_parallel, []) diff --git a/Tools/Scripts/webkitpy/common/system/filesystem_mock.py b/Tools/Scripts/webkitpy/common/system/filesystem_mock.py index d87fe1b8e..16e9fadaa 100644 --- a/Tools/Scripts/webkitpy/common/system/filesystem_mock.py +++ b/Tools/Scripts/webkitpy/common/system/filesystem_mock.py @@ -108,9 +108,9 @@ class MockFileSystem(object): if not self.exists(source): self._raise_not_found(source) if self.isdir(source): - raise IOError(errno.EISDIR, source, os.strerror(errno.ISDIR)) + raise IOError(errno.EISDIR, source, os.strerror(errno.EISDIR)) if self.isdir(destination): - raise IOError(errno.EISDIR, destination, os.strerror(errno.ISDIR)) + raise IOError(errno.EISDIR, destination, os.strerror(errno.EISDIR)) if not self.exists(self.dirname(destination)): raise IOError(errno.ENOENT, destination, os.strerror(errno.ENOENT)) diff --git a/Tools/Scripts/webkitpy/common/system/filesystem_mock_unittest.py b/Tools/Scripts/webkitpy/common/system/filesystem_mock_unittest.py index 2a6ccbf4b..391c1d954 100644 --- a/Tools/Scripts/webkitpy/common/system/filesystem_mock_unittest.py +++ b/Tools/Scripts/webkitpy/common/system/filesystem_mock_unittest.py @@ -52,7 +52,7 @@ class MockFileSystemTest(unittest.TestCase, filesystem_unittest.GenericFileSyste else: expected = good_fn(test) actual = test_fn(test) - self.assertEquals(expected, actual, 'given %s, expected %s, got %s' % (repr(test), repr(expected), repr(actual))) + self.assertEqual(expected, actual, 'given %s, expected %s, got %s' % (repr(test), repr(expected), repr(actual))) def test_join(self): self.quick_check(self.fs.join, diff --git a/Tools/Scripts/webkitpy/common/system/filesystem_unittest.py b/Tools/Scripts/webkitpy/common/system/filesystem_unittest.py index e6d1e428f..d656b2580 100644 --- a/Tools/Scripts/webkitpy/common/system/filesystem_unittest.py +++ b/Tools/Scripts/webkitpy/common/system/filesystem_unittest.py @@ -60,19 +60,19 @@ class GenericFileSystemTests(object): def test_glob__trailing_asterisk(self): self.fs.chdir(self.generic_test_dir) - self.assertEquals(set(self.fs.glob('fo*')), set(['foo.txt', 'foobar', 'foodir'])) + self.assertEqual(set(self.fs.glob('fo*')), set(['foo.txt', 'foobar', 'foodir'])) def test_glob__leading_asterisk(self): self.fs.chdir(self.generic_test_dir) - self.assertEquals(set(self.fs.glob('*xt')), set(['foo.txt'])) + self.assertEqual(set(self.fs.glob('*xt')), set(['foo.txt'])) def test_glob__middle_asterisk(self): self.fs.chdir(self.generic_test_dir) - self.assertEquals(set(self.fs.glob('f*r')), set(['foobar', 'foodir'])) + self.assertEqual(set(self.fs.glob('f*r')), set(['foobar', 'foodir'])) def test_glob__period_is_escaped(self): self.fs.chdir(self.generic_test_dir) - self.assertEquals(set(self.fs.glob('foo.*')), set(['foo.txt'])) + self.assertEqual(set(self.fs.glob('foo.*')), set(['foo.txt'])) class RealFileSystemTest(unittest.TestCase, GenericFileSystemTests): def setUp(self): @@ -94,7 +94,7 @@ class RealFileSystemTest(unittest.TestCase, GenericFileSystemTests): if sys.platform == 'win32': newdir = 'c:\\' fs.chdir(newdir) - self.assertEquals(fs.getcwd(), newdir) + self.assertEqual(fs.getcwd(), newdir) fs.chdir(cwd) def test_chdir__notexists(self): @@ -246,13 +246,13 @@ class RealFileSystemTest(unittest.TestCase, GenericFileSystemTests): fs = FileSystem() self.assertTrue(fs.remove('filename', remove_with_exception)) - self.assertEquals(-1, RealFileSystemTest._remove_failures) + self.assertEqual(-1, RealFileSystemTest._remove_failures) def test_sep(self): fs = FileSystem() - self.assertEquals(fs.sep, os.sep) - self.assertEquals(fs.join("foo", "bar"), + self.assertEqual(fs.sep, os.sep) + self.assertEqual(fs.join("foo", "bar"), os.path.join("foo", "bar")) diff --git a/Tools/Scripts/webkitpy/common/system/logtesting.py b/Tools/Scripts/webkitpy/common/system/logtesting.py index e361cb593..0cfa6cb0a 100644 --- a/Tools/Scripts/webkitpy/common/system/logtesting.py +++ b/Tools/Scripts/webkitpy/common/system/logtesting.py @@ -72,7 +72,7 @@ class TestLogStream(object): messages: A list of log message strings. """ - self._test_case.assertEquals(messages, self.messages) + self._test_case.assertEqual(messages, self.messages) class LogTesting(object): diff --git a/Tools/Scripts/webkitpy/common/system/logutils_unittest.py b/Tools/Scripts/webkitpy/common/system/logutils_unittest.py index 72789eb37..6d7cc4da4 100644 --- a/Tools/Scripts/webkitpy/common/system/logutils_unittest.py +++ b/Tools/Scripts/webkitpy/common/system/logutils_unittest.py @@ -37,7 +37,7 @@ class GetLoggerTest(unittest.TestCase): def test_get_logger_in_webkitpy(self): logger = logutils.get_logger(__file__) - self.assertEquals(logger.name, "webkitpy.common.system.logutils_unittest") + self.assertEqual(logger.name, "webkitpy.common.system.logutils_unittest") def test_get_logger_not_in_webkitpy(self): # Temporarily change the working directory so that we @@ -47,10 +47,10 @@ class GetLoggerTest(unittest.TestCase): os.chdir(root_dir) logger = logutils.get_logger("/Tools/Scripts/test-webkitpy") - self.assertEquals(logger.name, "test-webkitpy") + self.assertEqual(logger.name, "test-webkitpy") logger = logutils.get_logger("/Tools/Scripts/test-webkitpy.py") - self.assertEquals(logger.name, "test-webkitpy") + self.assertEqual(logger.name, "test-webkitpy") os.chdir(working_directory) diff --git a/Tools/Scripts/webkitpy/common/system/outputcapture.py b/Tools/Scripts/webkitpy/common/system/outputcapture.py index 78a12f0e2..26670d214 100644 --- a/Tools/Scripts/webkitpy/common/system/outputcapture.py +++ b/Tools/Scripts/webkitpy/common/system/outputcapture.py @@ -115,7 +115,7 @@ class OutputCaptureTestCaseBase(unittest.TestCase): unittest.TestCase.tearDown(self) def assertStdout(self, expected_stdout): - self.assertEquals(expected_stdout, self.__captured_stdout.getvalue()) + self.assertEqual(expected_stdout, self.__captured_stdout.getvalue()) def assertStderr(self, expected_stderr): - self.assertEquals(expected_stderr, self.__captured_stderr.getvalue()) + self.assertEqual(expected_stderr, self.__captured_stderr.getvalue()) diff --git a/Tools/Scripts/webkitpy/common/system/path_unittest.py b/Tools/Scripts/webkitpy/common/system/path_unittest.py index 954d32d71..7a719584d 100644 --- a/Tools/Scripts/webkitpy/common/system/path_unittest.py +++ b/Tools/Scripts/webkitpy/common/system/path_unittest.py @@ -41,28 +41,28 @@ class AbspathTest(unittest.TestCase): def test_abspath_to_uri_cygwin(self): if sys.platform != 'cygwin': return - self.assertEquals(path.abspath_to_uri(self.platforminfo(), '/cygdrive/c/foo/bar.html'), + self.assertEqual(path.abspath_to_uri(self.platforminfo(), '/cygdrive/c/foo/bar.html'), 'file:///C:/foo/bar.html') def test_abspath_to_uri_unixy(self): - self.assertEquals(path.abspath_to_uri(MockPlatformInfo(), "/foo/bar.html"), + self.assertEqual(path.abspath_to_uri(MockPlatformInfo(), "/foo/bar.html"), 'file:///foo/bar.html') def test_abspath_to_uri_win(self): if sys.platform != 'win32': return - self.assertEquals(path.abspath_to_uri(self.platforminfo(), 'c:\\foo\\bar.html'), + self.assertEqual(path.abspath_to_uri(self.platforminfo(), 'c:\\foo\\bar.html'), 'file:///c:/foo/bar.html') def test_abspath_to_uri_escaping_unixy(self): - self.assertEquals(path.abspath_to_uri(MockPlatformInfo(), '/foo/bar + baz%?.html'), + self.assertEqual(path.abspath_to_uri(MockPlatformInfo(), '/foo/bar + baz%?.html'), 'file:///foo/bar%20+%20baz%25%3F.html') # Note that you can't have '?' in a filename on windows. def test_abspath_to_uri_escaping_cygwin(self): if sys.platform != 'cygwin': return - self.assertEquals(path.abspath_to_uri(self.platforminfo(), '/cygdrive/c/foo/bar + baz%.html'), + self.assertEqual(path.abspath_to_uri(self.platforminfo(), '/cygdrive/c/foo/bar + baz%.html'), 'file:///C:/foo/bar%20+%20baz%25.html') def test_stop_cygpath_subprocess(self): diff --git a/Tools/Scripts/webkitpy/common/system/platforminfo_unittest.py b/Tools/Scripts/webkitpy/common/system/platforminfo_unittest.py index a2b4255b7..327229eb9 100644 --- a/Tools/Scripts/webkitpy/common/system/platforminfo_unittest.py +++ b/Tools/Scripts/webkitpy/common/system/platforminfo_unittest.py @@ -84,7 +84,7 @@ class TestPlatformInfo(unittest.TestCase): if info.is_mac(): self.assertTrue(info.total_bytes_memory() > 0) else: - self.assertEquals(info.total_bytes_memory(), None) + self.assertEqual(info.total_bytes_memory(), None) def test_os_name_and_wrappers(self): info = self.make_info(fake_sys('linux2')) @@ -100,28 +100,28 @@ class TestPlatformInfo(unittest.TestCase): self.assertFalse(info.is_freebsd()) info = self.make_info(fake_sys('darwin'), fake_platform('10.6.3')) - self.assertEquals(info.os_name, 'mac') + self.assertEqual(info.os_name, 'mac') self.assertFalse(info.is_linux()) self.assertTrue(info.is_mac()) self.assertFalse(info.is_win()) self.assertFalse(info.is_freebsd()) info = self.make_info(fake_sys('win32', tuple([6, 1, 7600]))) - self.assertEquals(info.os_name, 'win') + self.assertEqual(info.os_name, 'win') self.assertFalse(info.is_linux()) self.assertFalse(info.is_mac()) self.assertTrue(info.is_win()) self.assertFalse(info.is_freebsd()) info = self.make_info(fake_sys('cygwin'), executive=fake_executive('6.1.7600')) - self.assertEquals(info.os_name, 'win') + self.assertEqual(info.os_name, 'win') self.assertFalse(info.is_linux()) self.assertFalse(info.is_mac()) self.assertTrue(info.is_win()) self.assertFalse(info.is_freebsd()) info = self.make_info(fake_sys('freebsd8')) - self.assertEquals(info.os_name, 'freebsd') + self.assertEqual(info.os_name, 'freebsd') self.assertFalse(info.is_linux()) self.assertFalse(info.is_mac()) self.assertFalse(info.is_win()) @@ -131,28 +131,28 @@ class TestPlatformInfo(unittest.TestCase): def test_os_version(self): self.assertRaises(AssertionError, self.make_info, fake_sys('darwin'), fake_platform('10.4.3')) - self.assertEquals(self.make_info(fake_sys('darwin'), fake_platform('10.5.1')).os_version, 'leopard') - self.assertEquals(self.make_info(fake_sys('darwin'), fake_platform('10.6.1')).os_version, 'snowleopard') - self.assertEquals(self.make_info(fake_sys('darwin'), fake_platform('10.7.1')).os_version, 'lion') - self.assertEquals(self.make_info(fake_sys('darwin'), fake_platform('10.8.1')).os_version, 'mountainlion') - self.assertEquals(self.make_info(fake_sys('darwin'), fake_platform('10.9.0')).os_version, 'future') + self.assertEqual(self.make_info(fake_sys('darwin'), fake_platform('10.5.1')).os_version, 'leopard') + self.assertEqual(self.make_info(fake_sys('darwin'), fake_platform('10.6.1')).os_version, 'snowleopard') + self.assertEqual(self.make_info(fake_sys('darwin'), fake_platform('10.7.1')).os_version, 'lion') + self.assertEqual(self.make_info(fake_sys('darwin'), fake_platform('10.8.1')).os_version, 'mountainlion') + self.assertEqual(self.make_info(fake_sys('darwin'), fake_platform('10.9.0')).os_version, 'future') - self.assertEquals(self.make_info(fake_sys('linux2')).os_version, 'lucid') + self.assertEqual(self.make_info(fake_sys('linux2')).os_version, 'lucid') - self.assertEquals(self.make_info(fake_sys('freebsd8'), fake_platform('', '8.3-PRERELEASE')).os_version, '8.3-PRERELEASE') - self.assertEquals(self.make_info(fake_sys('freebsd9'), fake_platform('', '9.0-RELEASE')).os_version, '9.0-RELEASE') + self.assertEqual(self.make_info(fake_sys('freebsd8'), fake_platform('', '8.3-PRERELEASE')).os_version, '8.3-PRERELEASE') + self.assertEqual(self.make_info(fake_sys('freebsd9'), fake_platform('', '9.0-RELEASE')).os_version, '9.0-RELEASE') self.assertRaises(AssertionError, self.make_info, fake_sys('win32', tuple([5, 0, 1234]))) - self.assertEquals(self.make_info(fake_sys('win32', tuple([6, 2, 1234]))).os_version, 'future') - self.assertEquals(self.make_info(fake_sys('win32', tuple([6, 1, 7600]))).os_version, '7sp0') - self.assertEquals(self.make_info(fake_sys('win32', tuple([6, 0, 1234]))).os_version, 'vista') - self.assertEquals(self.make_info(fake_sys('win32', tuple([5, 1, 1234]))).os_version, 'xp') + self.assertEqual(self.make_info(fake_sys('win32', tuple([6, 2, 1234]))).os_version, 'future') + self.assertEqual(self.make_info(fake_sys('win32', tuple([6, 1, 7600]))).os_version, '7sp0') + self.assertEqual(self.make_info(fake_sys('win32', tuple([6, 0, 1234]))).os_version, 'vista') + self.assertEqual(self.make_info(fake_sys('win32', tuple([5, 1, 1234]))).os_version, 'xp') self.assertRaises(AssertionError, self.make_info, fake_sys('win32'), executive=fake_executive('5.0.1234')) - self.assertEquals(self.make_info(fake_sys('cygwin'), executive=fake_executive('6.2.1234')).os_version, 'future') - self.assertEquals(self.make_info(fake_sys('cygwin'), executive=fake_executive('6.1.7600')).os_version, '7sp0') - self.assertEquals(self.make_info(fake_sys('cygwin'), executive=fake_executive('6.0.1234')).os_version, 'vista') - self.assertEquals(self.make_info(fake_sys('cygwin'), executive=fake_executive('5.1.1234')).os_version, 'xp') + self.assertEqual(self.make_info(fake_sys('cygwin'), executive=fake_executive('6.2.1234')).os_version, 'future') + self.assertEqual(self.make_info(fake_sys('cygwin'), executive=fake_executive('6.1.7600')).os_version, '7sp0') + self.assertEqual(self.make_info(fake_sys('cygwin'), executive=fake_executive('6.0.1234')).os_version, 'vista') + self.assertEqual(self.make_info(fake_sys('cygwin'), executive=fake_executive('5.1.1234')).os_version, 'xp') def test_display_name(self): info = self.make_info(fake_sys('darwin')) @@ -169,16 +169,16 @@ class TestPlatformInfo(unittest.TestCase): def test_total_bytes_memory(self): info = self.make_info(fake_sys('darwin'), fake_platform('10.6.3'), fake_executive('1234')) - self.assertEquals(info.total_bytes_memory(), 1234) + self.assertEqual(info.total_bytes_memory(), 1234) info = self.make_info(fake_sys('win32', tuple([6, 1, 7600]))) - self.assertEquals(info.total_bytes_memory(), None) + self.assertEqual(info.total_bytes_memory(), None) info = self.make_info(fake_sys('linux2')) - self.assertEquals(info.total_bytes_memory(), None) + self.assertEqual(info.total_bytes_memory(), None) info = self.make_info(fake_sys('freebsd9')) - self.assertEquals(info.total_bytes_memory(), None) + self.assertEqual(info.total_bytes_memory(), None) if __name__ == '__main__': diff --git a/Tools/Scripts/webkitpy/common/system/user_unittest.py b/Tools/Scripts/webkitpy/common/system/user_unittest.py index 86b9db7d1..bd86d228f 100644 --- a/Tools/Scripts/webkitpy/common/system/user_unittest.py +++ b/Tools/Scripts/webkitpy/common/system/user_unittest.py @@ -120,12 +120,12 @@ class UserTest(unittest.TestCase): expected, inputs = test_case def mock_raw_input(message): - self.assertEquals(expected[0], message) + self.assertEqual(expected[0], message) return inputs[1] result = User().confirm(default=inputs[0], raw_input=mock_raw_input) - self.assertEquals(expected[1], result) + self.assertEqual(expected[1], result) def test_warn_if_application_is_xcode(self): output = OutputCapture() diff --git a/Tools/Scripts/webkitpy/common/system/zipfileset_unittest.py b/Tools/Scripts/webkitpy/common/system/zipfileset_unittest.py index 16a74cbd7..22ba72082 100644 --- a/Tools/Scripts/webkitpy/common/system/zipfileset_unittest.py +++ b/Tools/Scripts/webkitpy/common/system/zipfileset_unittest.py @@ -67,15 +67,15 @@ class ZipFileSetTest(unittest.TestCase): def test_open(self): file = self._zip.open('a/b/some-other-file') - self.assertEquals('a/b/some-other-file', file.name()) - self.assertEquals('other contents', file.contents()) + self.assertEqual('a/b/some-other-file', file.name()) + self.assertEqual('other contents', file.contents()) def test_close(self): zipfileset = ZipFileSet('blah', self._filesystem, self.make_fake_zip) zipfileset.close() def test_read(self): - self.assertEquals('contents', self._zip.read('some-file')) + self.assertEqual('contents', self._zip.read('some-file')) def test_extract(self): self._filesystem.maybe_make_directory('/some-dir') diff --git a/Tools/Scripts/webkitpy/common/watchlist/watchlist_unittest.py b/Tools/Scripts/webkitpy/common/watchlist/watchlist_unittest.py index 09010b288..67ff3b01a 100644 --- a/Tools/Scripts/webkitpy/common/watchlist/watchlist_unittest.py +++ b/Tools/Scripts/webkitpy/common/watchlist/watchlist_unittest.py @@ -52,7 +52,7 @@ class WatchListTest(unittest.TestCase): ' ],' ' },' '}') - self.assertEquals(set([]), watch_list.find_matching_definitions(DIFF_TEST_DATA)) + self.assertEqual(set([]), watch_list.find_matching_definitions(DIFF_TEST_DATA)) def test_filename_definition(self): watch_list = self._watch_list_parser.parse( @@ -68,7 +68,7 @@ class WatchListTest(unittest.TestCase): ' ],' ' },' '}') - self.assertEquals(set(['WatchList1']), watch_list.find_matching_definitions(DIFF_TEST_DATA)) + self.assertEqual(set(['WatchList1']), watch_list.find_matching_definitions(DIFF_TEST_DATA)) def test_cc_rules_simple(self): watch_list = self._watch_list_parser.parse( @@ -85,7 +85,7 @@ class WatchListTest(unittest.TestCase): ' },' '}') cc_and_messages = watch_list.determine_cc_and_messages(DIFF_TEST_DATA) - self.assertEquals({ + self.assertEqual({ 'cc_list': ['levin@chromium.org'], 'messages': [], }, cc_and_messages) @@ -109,7 +109,7 @@ class WatchListTest(unittest.TestCase): ' },' '}') cc_and_messages = watch_list.determine_cc_and_messages(DIFF_TEST_DATA) - self.assertEquals({ + self.assertEqual({ 'cc_list': ['levin@chromium.org'], 'messages': [], }, cc_and_messages) @@ -136,7 +136,7 @@ class WatchListTest(unittest.TestCase): ' },' '}') cc_and_messages = watch_list.determine_cc_and_messages(DIFF_TEST_DATA) - self.assertEquals({ + self.assertEqual({ 'cc_list': ['levin@chromium.org'], 'messages': ['msg1', 'msg2'], }, cc_and_messages) @@ -163,7 +163,7 @@ class WatchListTest(unittest.TestCase): ' },' '}') cc_and_messages = watch_list.determine_cc_and_messages(DIFF_TEST_DATA) - self.assertEquals({ + self.assertEqual({ 'cc_list': [], 'messages': [], }, cc_and_messages) @@ -185,7 +185,7 @@ class WatchListTest(unittest.TestCase): ' },' '}') cc_and_messages = watch_list.determine_cc_and_messages(DIFF_TEST_DATA) - self.assertEquals({ + self.assertEqual({ 'cc_list': ['eric@webkit.org'], 'messages': [], }, cc_and_messages) @@ -207,7 +207,7 @@ class WatchListTest(unittest.TestCase): ' },' '}') cc_and_messages = watch_list.determine_cc_and_messages(DIFF_TEST_DATA) - self.assertEquals({ + self.assertEqual({ 'cc_list': ['abarth@webkit.org'], 'messages': [], }, cc_and_messages) @@ -236,7 +236,7 @@ class WatchListTest(unittest.TestCase): ' },' '}') cc_and_messages = watch_list.determine_cc_and_messages(DIFF_TEST_DATA) - self.assertEquals({ + self.assertEqual({ 'cc_list': ['levin@chromium.org'], 'messages': ["Test message."], }, cc_and_messages) @@ -271,7 +271,7 @@ class WatchListTest(unittest.TestCase): ' },' '}') cc_and_messages = watch_list.determine_cc_and_messages(DIFF_TEST_DATA) - self.assertEquals({ + self.assertEqual({ 'cc_list': ['eric@webkit.org'], 'messages': ["This is a test message."], }, cc_and_messages) diff --git a/Tools/Scripts/webkitpy/common/webkit_finder.py b/Tools/Scripts/webkitpy/common/webkit_finder.py new file mode 100644 index 000000000..3705ef37f --- /dev/null +++ b/Tools/Scripts/webkitpy/common/webkit_finder.py @@ -0,0 +1,65 @@ +# Copyright (c) 2012 Google Inc. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +class WebKitFinder(object): + def __init__(self, filesystem): + self._filesystem = filesystem + self._webkit_base = None + + def webkit_base(self): + """Returns the absolute path to the top of the WebKit tree. + + Raises an AssertionError if the top dir can't be determined.""" + # Note: This code somewhat duplicates the code in + # scm.find_checkout_root(). However, that code only works if the top + # of the SCM repository also matches the top of the WebKit tree. Some SVN users + # (the chromium test bots, for example), might only check out subdirectories like + # Tools/Scripts. This code will also work if there is no SCM system at all. + if not self._webkit_base: + self._webkit_base = self._webkit_base + module_path = self._filesystem.path_to_module(self.__module__) + tools_index = module_path.find('Tools') + assert tools_index != -1, "could not find location of this checkout from %s" % module_path + self._webkit_base = self._filesystem.normpath(module_path[0:tools_index - 1]) + return self._webkit_base + + def path_from_webkit_base(self, *comps): + return self._filesystem.join(self.webkit_base(), *comps) + + def path_to_script(self, script_name): + """Returns the relative path to the script from the top of the WebKit tree.""" + # This is intentionally relative in order to force callers to consider what + # their current working directory is (and change to the top of the tree if necessary). + return self._filesystem.join("Tools", "Scripts", script_name) + + def layout_tests_dir(self): + return self.path_from_webkit_base('LayoutTests') + + def perf_tests_dir(self): + return self.path_from_webkit_base('PerformanceTests') diff --git a/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py b/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py index 4efa4e00c..501fb4326 100644 --- a/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py @@ -75,14 +75,14 @@ class LockCheckingRunner(LayoutTestRunner): def handle_finished_list(self, source, list_name, num_tests, elapsed_time): if not self._finished_list_called: - self._tester.assertEquals(list_name, 'locked_tests') + self._tester.assertEqual(list_name, 'locked_tests') self._tester.assertTrue(self._remaining_locked_shards) self._tester.assertTrue(self._has_http_lock is self._should_have_http_lock) super(LockCheckingRunner, self).handle_finished_list(source, list_name, num_tests, elapsed_time) if not self._finished_list_called: - self._tester.assertEquals(self._remaining_locked_shards, []) + self._tester.assertEqual(self._remaining_locked_shards, []) self._tester.assertFalse(self._has_http_lock) self._finished_list_called = True @@ -136,8 +136,8 @@ class LayoutTestRunnerTests(unittest.TestCase): # Interrupt if we've exceeded either limit: runner._options.exit_after_n_crashes_or_timeouts = 10 self.assertRaises(TestRunInterruptedException, runner._interrupt_if_at_failure_limits, result_summary) - self.assertEquals(result_summary.results['passes/text.html'].type, test_expectations.SKIP) - self.assertEquals(result_summary.results['passes/image.html'].type, test_expectations.SKIP) + self.assertEqual(result_summary.results['passes/text.html'].type, test_expectations.SKIP) + self.assertEqual(result_summary.results['passes/image.html'].type, test_expectations.SKIP) runner._options.exit_after_n_crashes_or_timeouts = None runner._options.exit_after_n_failures = 10 @@ -154,14 +154,14 @@ class LayoutTestRunnerTests(unittest.TestCase): result_summary = ResultSummary(expectations, [test], 1, set()) result = TestResult(test_name=test, failures=[test_failures.FailureReftestMismatchDidNotOccur()], reftest_type=['!=']) runner._update_summary_with_result(result_summary, result) - self.assertEquals(1, result_summary.expected) - self.assertEquals(0, result_summary.unexpected) + self.assertEqual(1, result_summary.expected) + self.assertEqual(0, result_summary.unexpected) result_summary = ResultSummary(expectations, [test], 1, set()) result = TestResult(test_name=test, failures=[], reftest_type=['==']) runner._update_summary_with_result(result_summary, result) - self.assertEquals(0, result_summary.expected) - self.assertEquals(1, result_summary.unexpected) + self.assertEqual(0, result_summary.expected) + self.assertEqual(1, result_summary.unexpected) def test_servers_started(self): @@ -189,31 +189,31 @@ class LayoutTestRunnerTests(unittest.TestCase): runner._needs_http = True runner._needs_websockets = False runner.start_servers_with_lock(number_of_servers=4) - self.assertEquals(self.http_started, True) - self.assertEquals(self.websocket_started, False) + self.assertEqual(self.http_started, True) + self.assertEqual(self.websocket_started, False) runner.stop_servers_with_lock() - self.assertEquals(self.http_stopped, True) - self.assertEquals(self.websocket_stopped, False) + self.assertEqual(self.http_stopped, True) + self.assertEqual(self.websocket_stopped, False) self.http_started = self.http_stopped = self.websocket_started = self.websocket_stopped = False runner._needs_http = True runner._needs_websockets = True runner.start_servers_with_lock(number_of_servers=4) - self.assertEquals(self.http_started, True) - self.assertEquals(self.websocket_started, True) + self.assertEqual(self.http_started, True) + self.assertEqual(self.websocket_started, True) runner.stop_servers_with_lock() - self.assertEquals(self.http_stopped, True) - self.assertEquals(self.websocket_stopped, True) + self.assertEqual(self.http_stopped, True) + self.assertEqual(self.websocket_stopped, True) self.http_started = self.http_stopped = self.websocket_started = self.websocket_stopped = False runner._needs_http = False runner._needs_websockets = False runner.start_servers_with_lock(number_of_servers=4) - self.assertEquals(self.http_started, False) - self.assertEquals(self.websocket_started, False) + self.assertEqual(self.http_started, False) + self.assertEqual(self.websocket_started, False) runner.stop_servers_with_lock() - self.assertEquals(self.http_stopped, False) - self.assertEquals(self.websocket_stopped, False) + self.assertEqual(self.http_stopped, False) + self.assertEqual(self.websocket_stopped, False) class SharderTests(unittest.TestCase): @@ -245,11 +245,11 @@ class SharderTests(unittest.TestCase): return self.sharder.shard_tests([self.get_test_input(test) for test in test_list], num_workers, fully_parallel) def assert_shards(self, actual_shards, expected_shard_names): - self.assertEquals(len(actual_shards), len(expected_shard_names)) + self.assertEqual(len(actual_shards), len(expected_shard_names)) for i, shard in enumerate(actual_shards): expected_shard_name, expected_test_names = expected_shard_names[i] - self.assertEquals(shard.name, expected_shard_name) - self.assertEquals([test_input.test_name for test_input in shard.test_inputs], + self.assertEqual(shard.name, expected_shard_name) + self.assertEqual([test_input.test_name for test_input in shard.test_inputs], expected_test_names) def test_shard_by_dir(self): @@ -307,14 +307,14 @@ class SharderTests(unittest.TestCase): def test_shard_in_two_has_no_locked_shards(self): locked, unlocked = self.get_shards(num_workers=1, fully_parallel=False, test_list=['animations/keyframe.html']) - self.assertEquals(len(locked), 0) - self.assertEquals(len(unlocked), 1) + self.assertEqual(len(locked), 0) + self.assertEqual(len(unlocked), 1) def test_shard_in_two_has_no_unlocked_shards(self): locked, unlocked = self.get_shards(num_workers=1, fully_parallel=False, test_list=['http/tests/websocket/tests/unicode.htm']) - self.assertEquals(len(locked), 1) - self.assertEquals(len(unlocked), 0) + self.assertEqual(len(locked), 1) + self.assertEqual(len(unlocked), 0) def test_multiple_locked_shards(self): locked, unlocked = self.get_shards(num_workers=4, fully_parallel=False, max_locked_shards=2) @@ -339,7 +339,7 @@ class SharderTests(unittest.TestCase): class NaturalCompareTest(unittest.TestCase): def assert_cmp(self, x, y, result): - self.assertEquals(cmp(Sharder.natural_sort_key(x), Sharder.natural_sort_key(y)), result) + self.assertEqual(cmp(Sharder.natural_sort_key(x), Sharder.natural_sort_key(y)), result) def test_natural_compare(self): self.assert_cmp('a', 'a', 0) @@ -369,7 +369,7 @@ class KeyCompareTest(unittest.TestCase): self.sharder = Sharder(split, '/', 1) def assert_cmp(self, x, y, result): - self.assertEquals(cmp(self.sharder.test_key(x), self.sharder.test_key(y)), result) + self.assertEqual(cmp(self.sharder.test_key(x), self.sharder.test_key(y)), result) def test_test_key(self): self.assert_cmp('/a', '/a', 0) diff --git a/Tools/Scripts/webkitpy/layout_tests/controllers/manager.py b/Tools/Scripts/webkitpy/layout_tests/controllers/manager.py index 636edd2be..cc2f0f9b9 100644 --- a/Tools/Scripts/webkitpy/layout_tests/controllers/manager.py +++ b/Tools/Scripts/webkitpy/layout_tests/controllers/manager.py @@ -300,9 +300,6 @@ class Manager(object): def _http_tests(self): return set(test for test in self._test_names if self._is_http_test(test)) - def _websocket_tests(self): - return set(test for test in self._test_files if self._is_websocket(test)) - def _is_perf_test(self, test): return self.PERF_SUBDIR == test or (self.PERF_SUBDIR + self._port.TEST_PATH_SEPARATOR) in test diff --git a/Tools/Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py b/Tools/Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py index 5c43b6ac6..ec99cf6b4 100644 --- a/Tools/Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py @@ -51,22 +51,22 @@ class TestConfigurationTest(unittest.TestCase): result_config_dict = {} for category, specifier in config.items(): result_config_dict[category] = specifier - self.assertEquals({'version': 'xp', 'architecture': 'x86', 'build_type': 'release'}, result_config_dict) + self.assertEqual({'version': 'xp', 'architecture': 'x86', 'build_type': 'release'}, result_config_dict) def test_keys(self): config = TestConfiguration('xp', 'x86', 'release') result_config_keys = [] for category in config.keys(): result_config_keys.append(category) - self.assertEquals(set(['version', 'architecture', 'build_type']), set(result_config_keys)) + self.assertEqual(set(['version', 'architecture', 'build_type']), set(result_config_keys)) def test_str(self): config = TestConfiguration('xp', 'x86', 'release') - self.assertEquals('<xp, x86, release>', str(config)) + self.assertEqual('<xp, x86, release>', str(config)) def test_repr(self): config = TestConfiguration('xp', 'x86', 'release') - self.assertEquals("TestConfig(version='xp', architecture='x86', build_type='release')", repr(config)) + self.assertEqual("TestConfig(version='xp', architecture='x86', build_type='release')", repr(config)) def test_hash(self): config_dict = {} @@ -81,11 +81,11 @@ class TestConfigurationTest(unittest.TestCase): self.assertTrue(TestConfiguration('xp', 'x86', 'release') in config_dict) self.assertFalse(TestConfiguration('xp', 'x86', 'debug') in config_dict) configs_list = [TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug'), TestConfiguration('xp', 'x86', 'debug')] - self.assertEquals(len(configs_list), 3) - self.assertEquals(len(set(configs_list)), 2) + self.assertEqual(len(configs_list), 3) + self.assertEqual(len(set(configs_list)), 2) def test_eq(self): - self.assertEquals(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'release')) + self.assertEqual(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'release')) self.assertNotEquals(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug')) def test_values(self): @@ -93,7 +93,7 @@ class TestConfigurationTest(unittest.TestCase): result_config_values = [] for value in config.values(): result_config_values.append(value) - self.assertEquals(set(['xp', 'x86', 'release']), set(result_config_values)) + self.assertEqual(set(['xp', 'x86', 'release']), set(result_config_values)) class SpecifierSorterTest(unittest.TestCase): @@ -103,48 +103,48 @@ class SpecifierSorterTest(unittest.TestCase): def test_init(self): sorter = SpecifierSorter() - self.assertEquals(sorter.category_for_specifier('control'), None) + self.assertEqual(sorter.category_for_specifier('control'), None) sorter = SpecifierSorter(self._all_test_configurations) - self.assertEquals(sorter.category_for_specifier('xp'), 'version') + self.assertEqual(sorter.category_for_specifier('xp'), 'version') sorter = SpecifierSorter(self._all_test_configurations, MOCK_MACROS) - self.assertEquals(sorter.category_for_specifier('mac'), 'version') + self.assertEqual(sorter.category_for_specifier('mac'), 'version') def test_add_specifier(self): sorter = SpecifierSorter() - self.assertEquals(sorter.category_for_specifier('control'), None) + self.assertEqual(sorter.category_for_specifier('control'), None) sorter.add_specifier('version', 'control') - self.assertEquals(sorter.category_for_specifier('control'), 'version') + self.assertEqual(sorter.category_for_specifier('control'), 'version') sorter.add_specifier('version', 'one') - self.assertEquals(sorter.category_for_specifier('one'), 'version') + self.assertEqual(sorter.category_for_specifier('one'), 'version') sorter.add_specifier('architecture', 'renaissance') - self.assertEquals(sorter.category_for_specifier('one'), 'version') - self.assertEquals(sorter.category_for_specifier('renaissance'), 'architecture') + self.assertEqual(sorter.category_for_specifier('one'), 'version') + self.assertEqual(sorter.category_for_specifier('renaissance'), 'architecture') def test_add_macros(self): sorter = SpecifierSorter(self._all_test_configurations) sorter.add_macros(MOCK_MACROS) - self.assertEquals(sorter.category_for_specifier('mac'), 'version') - self.assertEquals(sorter.category_for_specifier('win'), 'version') - self.assertEquals(sorter.category_for_specifier('x86'), 'architecture') + self.assertEqual(sorter.category_for_specifier('mac'), 'version') + self.assertEqual(sorter.category_for_specifier('win'), 'version') + self.assertEqual(sorter.category_for_specifier('x86'), 'architecture') def test_category_priority(self): sorter = SpecifierSorter(self._all_test_configurations) - self.assertEquals(sorter.category_priority('version'), 0) - self.assertEquals(sorter.category_priority('build_type'), 2) + self.assertEqual(sorter.category_priority('version'), 0) + self.assertEqual(sorter.category_priority('build_type'), 2) def test_specifier_priority(self): sorter = SpecifierSorter(self._all_test_configurations) - self.assertEquals(sorter.specifier_priority('x86'), 1) - self.assertEquals(sorter.specifier_priority('snowleopard'), 0) + self.assertEqual(sorter.specifier_priority('x86'), 1) + self.assertEqual(sorter.specifier_priority('snowleopard'), 0) def test_sort_specifiers(self): sorter = SpecifierSorter(self._all_test_configurations, MOCK_MACROS) - self.assertEquals(sorter.sort_specifiers(set()), []) - self.assertEquals(sorter.sort_specifiers(set(['x86'])), ['x86']) - self.assertEquals(sorter.sort_specifiers(set(['x86', 'win7'])), ['win7', 'x86']) - self.assertEquals(sorter.sort_specifiers(set(['x86', 'debug', 'win7'])), ['win7', 'x86', 'debug']) - self.assertEquals(sorter.sort_specifiers(set(['snowleopard', 'x86', 'debug', 'win7'])), ['snowleopard', 'win7', 'x86', 'debug']) - self.assertEquals(sorter.sort_specifiers(set(['x86', 'mac', 'debug', 'win7'])), ['mac', 'win7', 'x86', 'debug']) + self.assertEqual(sorter.sort_specifiers(set()), []) + self.assertEqual(sorter.sort_specifiers(set(['x86'])), ['x86']) + self.assertEqual(sorter.sort_specifiers(set(['x86', 'win7'])), ['win7', 'x86']) + self.assertEqual(sorter.sort_specifiers(set(['x86', 'debug', 'win7'])), ['win7', 'x86', 'debug']) + self.assertEqual(sorter.sort_specifiers(set(['snowleopard', 'x86', 'debug', 'win7'])), ['snowleopard', 'win7', 'x86', 'debug']) + self.assertEqual(sorter.sort_specifiers(set(['x86', 'mac', 'debug', 'win7'])), ['mac', 'win7', 'x86', 'debug']) class TestConfigurationConverterTest(unittest.TestCase): @@ -153,28 +153,28 @@ class TestConfigurationConverterTest(unittest.TestCase): unittest.TestCase.__init__(self, testFunc) def test_symmetric_difference(self): - self.assertEquals(TestConfigurationConverter.symmetric_difference([set(['a', 'b']), set(['b', 'c'])]), set(['a', 'c'])) - self.assertEquals(TestConfigurationConverter.symmetric_difference([set(['a', 'b']), set(['b', 'c']), set(['b', 'd'])]), set(['a', 'c', 'd'])) + self.assertEqual(TestConfigurationConverter.symmetric_difference([set(['a', 'b']), set(['b', 'c'])]), set(['a', 'c'])) + self.assertEqual(TestConfigurationConverter.symmetric_difference([set(['a', 'b']), set(['b', 'c']), set(['b', 'd'])]), set(['a', 'c', 'd'])) def test_to_config_set(self): converter = TestConfigurationConverter(self._all_test_configurations) - self.assertEquals(converter.to_config_set(set()), self._all_test_configurations) + self.assertEqual(converter.to_config_set(set()), self._all_test_configurations) - self.assertEquals(converter.to_config_set(set(['foo'])), set()) + self.assertEqual(converter.to_config_set(set(['foo'])), set()) - self.assertEquals(converter.to_config_set(set(['xp', 'foo'])), set()) + self.assertEqual(converter.to_config_set(set(['xp', 'foo'])), set()) errors = [] - self.assertEquals(converter.to_config_set(set(['xp', 'foo']), errors), set()) - self.assertEquals(errors, ["Unrecognized modifier 'foo'"]) + self.assertEqual(converter.to_config_set(set(['xp', 'foo']), errors), set()) + self.assertEqual(errors, ["Unrecognized modifier 'foo'"]) - self.assertEquals(converter.to_config_set(set(['xp', 'x86_64'])), set()) + self.assertEqual(converter.to_config_set(set(['xp', 'x86_64'])), set()) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), ]) - self.assertEquals(converter.to_config_set(set(['xp', 'release'])), configs_to_match) + self.assertEqual(converter.to_config_set(set(['xp', 'release'])), configs_to_match) configs_to_match = set([ TestConfiguration('snowleopard', 'x86', 'release'), @@ -184,13 +184,13 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('lucid', 'x86', 'release'), TestConfiguration('lucid', 'x86_64', 'release'), ]) - self.assertEquals(converter.to_config_set(set(['release'])), configs_to_match) + self.assertEqual(converter.to_config_set(set(['release'])), configs_to_match) configs_to_match = set([ TestConfiguration('lucid', 'x86_64', 'release'), TestConfiguration('lucid', 'x86_64', 'debug'), ]) - self.assertEquals(converter.to_config_set(set(['x86_64'])), configs_to_match) + self.assertEqual(converter.to_config_set(set(['x86_64'])), configs_to_match) configs_to_match = set([ TestConfiguration('lucid', 'x86_64', 'release'), @@ -200,7 +200,7 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('snowleopard', 'x86', 'release'), TestConfiguration('snowleopard', 'x86', 'debug'), ]) - self.assertEquals(converter.to_config_set(set(['lucid', 'snowleopard'])), configs_to_match) + self.assertEqual(converter.to_config_set(set(['lucid', 'snowleopard'])), configs_to_match) configs_to_match = set([ TestConfiguration('lucid', 'x86', 'release'), @@ -208,14 +208,14 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('snowleopard', 'x86', 'release'), TestConfiguration('snowleopard', 'x86', 'debug'), ]) - self.assertEquals(converter.to_config_set(set(['lucid', 'snowleopard', 'x86'])), configs_to_match) + self.assertEqual(converter.to_config_set(set(['lucid', 'snowleopard', 'x86'])), configs_to_match) configs_to_match = set([ TestConfiguration('lucid', 'x86_64', 'release'), TestConfiguration('lucid', 'x86', 'release'), TestConfiguration('snowleopard', 'x86', 'release'), ]) - self.assertEquals(converter.to_config_set(set(['lucid', 'snowleopard', 'release'])), configs_to_match) + self.assertEqual(converter.to_config_set(set(['lucid', 'snowleopard', 'release'])), configs_to_match) def test_macro_expansion(self): converter = TestConfigurationConverter(self._all_test_configurations, MOCK_MACROS) @@ -225,7 +225,7 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('vista', 'x86', 'release'), TestConfiguration('win7', 'x86', 'release'), ]) - self.assertEquals(converter.to_config_set(set(['win', 'release'])), configs_to_match) + self.assertEqual(converter.to_config_set(set(['win', 'release'])), configs_to_match) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), @@ -234,7 +234,7 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('lucid', 'x86', 'release'), TestConfiguration('lucid', 'x86_64', 'release'), ]) - self.assertEquals(converter.to_config_set(set(['win', 'lucid', 'release'])), configs_to_match) + self.assertEqual(converter.to_config_set(set(['win', 'lucid', 'release'])), configs_to_match) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), @@ -242,30 +242,30 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('win7', 'x86', 'release'), TestConfiguration('snowleopard', 'x86', 'release'), ]) - self.assertEquals(converter.to_config_set(set(['win', 'mac', 'release'])), configs_to_match) + self.assertEqual(converter.to_config_set(set(['win', 'mac', 'release'])), configs_to_match) def test_to_specifier_lists(self): converter = TestConfigurationConverter(self._all_test_configurations, MOCK_MACROS) - self.assertEquals(converter.to_specifiers_list(set(self._all_test_configurations)), [[]]) - self.assertEquals(converter.to_specifiers_list(set()), []) + self.assertEqual(converter.to_specifiers_list(set(self._all_test_configurations)), [[]]) + self.assertEqual(converter.to_specifiers_list(set()), []) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['release', 'xp'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['release', 'xp'])]) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['xp'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['xp'])]) configs_to_match = set([ TestConfiguration('lucid', 'x86_64', 'debug'), TestConfiguration('xp', 'x86', 'release'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['release', 'xp']), set(['debug', 'x86_64', 'linux'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['release', 'xp']), set(['debug', 'x86_64', 'linux'])]) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), @@ -275,7 +275,7 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('lucid', 'x86_64', 'debug'), TestConfiguration('lucid', 'x86', 'debug'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['release', 'xp']), set(['debug', 'linux'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['release', 'xp']), set(['debug', 'linux'])]) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), @@ -285,13 +285,13 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('lucid', 'x86', 'release'), TestConfiguration('lucid', 'x86_64', 'release'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['release'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['release'])]) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), TestConfiguration('snowleopard', 'x86', 'release'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['xp', 'mac', 'release'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['xp', 'mac', 'release'])]) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), @@ -300,26 +300,26 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('win7', 'x86', 'debug'), TestConfiguration('lucid', 'x86', 'release'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['win7']), set(['release', 'linux', 'x86']), set(['release', 'xp', 'mac'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['win7']), set(['release', 'linux', 'x86']), set(['release', 'xp', 'mac'])]) def test_macro_collapsing(self): macros = {'foo': ['bar', 'baz'], 'people': ['bob', 'alice', 'john']} specifiers_list = [set(['john', 'godzilla', 'bob', 'alice'])] TestConfigurationConverter.collapse_macros(macros, specifiers_list) - self.assertEquals(specifiers_list, [set(['people', 'godzilla'])]) + self.assertEqual(specifiers_list, [set(['people', 'godzilla'])]) specifiers_list = [set(['john', 'godzilla', 'alice'])] TestConfigurationConverter.collapse_macros(macros, specifiers_list) - self.assertEquals(specifiers_list, [set(['john', 'godzilla', 'alice', 'godzilla'])]) + self.assertEqual(specifiers_list, [set(['john', 'godzilla', 'alice', 'godzilla'])]) specifiers_list = [set(['bar', 'godzilla', 'baz', 'bob', 'alice', 'john'])] TestConfigurationConverter.collapse_macros(macros, specifiers_list) - self.assertEquals(specifiers_list, [set(['foo', 'godzilla', 'people'])]) + self.assertEqual(specifiers_list, [set(['foo', 'godzilla', 'people'])]) specifiers_list = [set(['bar', 'godzilla', 'baz', 'bob']), set(['bar', 'baz']), set(['people', 'alice', 'bob', 'john'])] TestConfigurationConverter.collapse_macros(macros, specifiers_list) - self.assertEquals(specifiers_list, [set(['bob', 'foo', 'godzilla']), set(['foo']), set(['people'])]) + self.assertEqual(specifiers_list, [set(['bob', 'foo', 'godzilla']), set(['foo']), set(['people'])]) def test_converter_macro_collapsing(self): converter = TestConfigurationConverter(self._all_test_configurations, MOCK_MACROS) @@ -329,7 +329,7 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('vista', 'x86', 'release'), TestConfiguration('win7', 'x86', 'release'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['win', 'release'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['win', 'release'])]) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), @@ -338,7 +338,7 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('lucid', 'x86', 'release'), TestConfiguration('lucid', 'x86_64', 'release'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['win', 'linux', 'release'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['win', 'linux', 'release'])]) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), @@ -346,7 +346,7 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('win7', 'x86', 'release'), TestConfiguration('snowleopard', 'x86', 'release'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['win', 'mac', 'release'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['win', 'mac', 'release'])]) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), @@ -354,16 +354,16 @@ class TestConfigurationConverterTest(unittest.TestCase): TestConfiguration('win7', 'x86', 'release'), TestConfiguration('snowleopard', 'x86', 'release'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['win', 'mac', 'release'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['win', 'mac', 'release'])]) configs_to_match = set([ TestConfiguration('xp', 'x86', 'release'), TestConfiguration('vista', 'x86', 'release'), TestConfiguration('win7', 'x86', 'release'), ]) - self.assertEquals(converter.to_specifiers_list(configs_to_match), [set(['win', 'release'])]) + self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['win', 'release'])]) def test_specifier_converter_access(self): specifier_sorter = TestConfigurationConverter(self._all_test_configurations, MOCK_MACROS).specifier_sorter() - self.assertEquals(specifier_sorter.category_for_specifier('snowleopard'), 'version') - self.assertEquals(specifier_sorter.category_for_specifier('mac'), 'version') + self.assertEqual(specifier_sorter.category_for_specifier('snowleopard'), 'version') + self.assertEqual(specifier_sorter.category_for_specifier('mac'), 'version') diff --git a/Tools/Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py b/Tools/Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py index d78ae3f2b..bbe031cde 100644 --- a/Tools/Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py @@ -84,7 +84,7 @@ Bug(test) failures/expected/image.html [ WontFix Mac ] self._exp = TestExpectations(self._port, self.get_basic_tests(), expectations_to_lint=expectations_to_lint) def assert_exp(self, test, result): - self.assertEquals(self._exp.get_expectations(self.get_test(test)), + self.assertEqual(self._exp.get_expectations(self.get_test(test)), set([result])) def assert_bad_expectations(self, expectations, overrides=None): @@ -109,29 +109,29 @@ class MiscTests(Base): def test_result_was_expected(self): # test basics - self.assertEquals(TestExpectations.result_was_expected(PASS, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), True) - self.assertEquals(TestExpectations.result_was_expected(FAIL, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), False) + self.assertEqual(TestExpectations.result_was_expected(PASS, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), True) + self.assertEqual(TestExpectations.result_was_expected(FAIL, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), False) # test handling of SKIPped tests and results - self.assertEquals(TestExpectations.result_was_expected(SKIP, set([CRASH]), test_needs_rebaselining=False, test_is_skipped=True), True) - self.assertEquals(TestExpectations.result_was_expected(SKIP, set([CRASH]), test_needs_rebaselining=False, test_is_skipped=False), False) + self.assertEqual(TestExpectations.result_was_expected(SKIP, set([CRASH]), test_needs_rebaselining=False, test_is_skipped=True), True) + self.assertEqual(TestExpectations.result_was_expected(SKIP, set([CRASH]), test_needs_rebaselining=False, test_is_skipped=False), False) # test handling of MISSING results and the REBASELINE modifier - self.assertEquals(TestExpectations.result_was_expected(MISSING, set([PASS]), test_needs_rebaselining=True, test_is_skipped=False), True) - self.assertEquals(TestExpectations.result_was_expected(MISSING, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), False) + self.assertEqual(TestExpectations.result_was_expected(MISSING, set([PASS]), test_needs_rebaselining=True, test_is_skipped=False), True) + self.assertEqual(TestExpectations.result_was_expected(MISSING, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), False) def test_remove_pixel_failures(self): - self.assertEquals(TestExpectations.remove_pixel_failures(set([FAIL])), set([FAIL])) - self.assertEquals(TestExpectations.remove_pixel_failures(set([PASS])), set([PASS])) - self.assertEquals(TestExpectations.remove_pixel_failures(set([IMAGE])), set([PASS])) - self.assertEquals(TestExpectations.remove_pixel_failures(set([FAIL])), set([FAIL])) - self.assertEquals(TestExpectations.remove_pixel_failures(set([PASS, IMAGE, CRASH])), set([PASS, CRASH])) + self.assertEqual(TestExpectations.remove_pixel_failures(set([FAIL])), set([FAIL])) + self.assertEqual(TestExpectations.remove_pixel_failures(set([PASS])), set([PASS])) + self.assertEqual(TestExpectations.remove_pixel_failures(set([IMAGE])), set([PASS])) + self.assertEqual(TestExpectations.remove_pixel_failures(set([FAIL])), set([FAIL])) + self.assertEqual(TestExpectations.remove_pixel_failures(set([PASS, IMAGE, CRASH])), set([PASS, CRASH])) def test_suffixes_for_expectations(self): - self.assertEquals(TestExpectations.suffixes_for_expectations(set([FAIL])), set(['txt', 'png', 'wav'])) - self.assertEquals(TestExpectations.suffixes_for_expectations(set([IMAGE])), set(['png'])) - self.assertEquals(TestExpectations.suffixes_for_expectations(set([FAIL, IMAGE, CRASH])), set(['txt', 'png', 'wav'])) - self.assertEquals(TestExpectations.suffixes_for_expectations(set()), set()) + self.assertEqual(TestExpectations.suffixes_for_expectations(set([FAIL])), set(['txt', 'png', 'wav'])) + self.assertEqual(TestExpectations.suffixes_for_expectations(set([IMAGE])), set(['png'])) + self.assertEqual(TestExpectations.suffixes_for_expectations(set([FAIL, IMAGE, CRASH])), set(['txt', 'png', 'wav'])) + self.assertEqual(TestExpectations.suffixes_for_expectations(set()), set()) def test_category_expectations(self): # This test checks unknown tests are not present in the @@ -152,7 +152,7 @@ class MiscTests(Base): def test_get_expectations_string(self): self.parse_exp(self.get_basic_expectations()) - self.assertEquals(self._exp.get_expectations_string( + self.assertEqual(self._exp.get_expectations_string( self.get_test('failures/expected/text.html')), 'FAIL') @@ -261,9 +261,9 @@ class SkippedTests(Base): exp = TestExpectations(port, ['failures/expected/text.html'], expectations_to_lint=expectations_to_lint) # Check that the expectation is for BUG_DUMMY SKIP : ... [ Pass ] - self.assertEquals(exp.get_modifiers('failures/expected/text.html'), + self.assertEqual(exp.get_modifiers('failures/expected/text.html'), [TestExpectationParser.DUMMY_BUG_MODIFIER, TestExpectationParser.SKIP_MODIFIER, TestExpectationParser.WONTFIX_MODIFIER]) - self.assertEquals(exp.get_expectations('failures/expected/text.html'), set([PASS])) + self.assertEqual(exp.get_expectations('failures/expected/text.html'), set([PASS])) def test_skipped_tests_work(self): self.check(expectations='', overrides=None, skips=['failures/expected/text.html']) @@ -317,13 +317,13 @@ class ExpectationSyntaxTests(Base): filename = 'TestExpectations' line_number = 1 expectation_line = TestExpectationParser._tokenize_line(filename, line, line_number) - self.assertEquals(expectation_line.warnings, warnings) - self.assertEquals(expectation_line.name, name) - self.assertEquals(expectation_line.filename, filename) - self.assertEquals(expectation_line.line_number, line_number) + self.assertEqual(expectation_line.warnings, warnings) + self.assertEqual(expectation_line.name, name) + self.assertEqual(expectation_line.filename, filename) + self.assertEqual(expectation_line.line_number, line_number) if not warnings: - self.assertEquals(expectation_line.modifiers, modifiers) - self.assertEquals(expectation_line.expectations, expectations) + self.assertEqual(expectation_line.modifiers, modifiers) + self.assertEqual(expectation_line.expectations, expectations) def test_bare_name(self): self.assert_tokenize_exp('foo.html', modifiers=['SKIP'], expectations=['PASS']) @@ -378,7 +378,7 @@ class SemanticTests(Base): self.parse_exp('BUG1234 failures/expected/text.html [ Failure ]', is_lint_mode=True) self.fail('should have raised an error about a bad bug identifier') except ParseError, exp: - self.assertEquals(len(exp.warnings), 1) + self.assertEqual(len(exp.warnings), 1) def test_missing_bugid(self): self.parse_exp('failures/expected/text.html [ Failure ]') @@ -389,7 +389,7 @@ class SemanticTests(Base): self.parse_exp('failures/expected/text.html [ Failure ]') line = self._exp._model.get_expectation_line('failures/expected/text.html') self.assertFalse(line.is_invalid()) - self.assertEquals(line.warnings, ['Test lacks BUG modifier.']) + self.assertEqual(line.warnings, ['Test lacks BUG modifier.']) def test_skip_and_wontfix(self): # Skip and WontFix are not allowed to have other expectations as well, because those @@ -692,9 +692,9 @@ class TestExpectationSerializationTests(unittest.TestCase): add_line(set([TestConfiguration('xp', 'x86', 'release')]), True) add_line(set([TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug')]), False) serialized = TestExpectations.list_to_string(lines, self._converter) - self.assertEquals(serialized, "Bug(x) [ XP Release ] Yay [ ImageOnlyFailure ]\nBug(x) [ XP ] Yay [ ImageOnlyFailure ]") + self.assertEqual(serialized, "Bug(x) [ XP Release ] Yay [ ImageOnlyFailure ]\nBug(x) [ XP ] Yay [ ImageOnlyFailure ]") serialized = TestExpectations.list_to_string(lines, self._converter, reconstitute_only_these=reconstitute_only_these) - self.assertEquals(serialized, "Bug(x) [ XP Release ] Yay [ ImageOnlyFailure ]\nNay") + self.assertEqual(serialized, "Bug(x) [ XP Release ] Yay [ ImageOnlyFailure ]\nNay") def test_string_whitespace_stripping(self): self.assert_round_trip('\n', '') diff --git a/Tools/Scripts/webkitpy/layout_tests/models/test_failures_unittest.py b/Tools/Scripts/webkitpy/layout_tests/models/test_failures_unittest.py index 1c8f029a6..74ef8cbb4 100644 --- a/Tools/Scripts/webkitpy/layout_tests/models/test_failures_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/models/test_failures_unittest.py @@ -69,5 +69,5 @@ class TestFailuresTest(unittest.TestCase): self.assertEqual(len(crash_set), 2) def test_crashes(self): - self.assertEquals(FailureCrash().message(), 'DumpRenderTree crashed') - self.assertEquals(FailureCrash(process_name='foo', pid=1234).message(), 'foo crashed [pid=1234]') + self.assertEqual(FailureCrash().message(), 'DumpRenderTree crashed') + self.assertEqual(FailureCrash(process_name='foo', pid=1234).message(), 'foo crashed [pid=1234]') diff --git a/Tools/Scripts/webkitpy/layout_tests/port/apple.py b/Tools/Scripts/webkitpy/layout_tests/port/apple.py index 4b97f419b..d434c8da8 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/apple.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/apple.py @@ -49,6 +49,10 @@ class ApplePort(Port): # It's possible that Apple would want to fix this code to work better with those results. FUTURE_VERSION = 'future' # FIXME: This whole 'future' thing feels like a hack. + # overridden in subclasses + VERSION_FALLBACK_ORDER = [] + ARCHITECTURES = [] + @classmethod def determine_full_port_name(cls, host, options, port_name): # If the port_name matches the (badly named) cls.port_name, that diff --git a/Tools/Scripts/webkitpy/layout_tests/port/base.py b/Tools/Scripts/webkitpy/layout_tests/port/base.py index ea1e9d033..a19af094c 100755 --- a/Tools/Scripts/webkitpy/layout_tests/port/base.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/base.py @@ -54,6 +54,7 @@ from webkitpy.common.memoized import memoized from webkitpy.common.system import path from webkitpy.common.system.executive import ScriptError from webkitpy.common.system.systemhost import SystemHost +from webkitpy.common.webkit_finder import WebKitFinder from webkitpy.layout_tests.models.test_configuration import TestConfiguration from webkitpy.layout_tests.port import config as port_config from webkitpy.layout_tests.port import driver @@ -90,7 +91,7 @@ class Port(object): # Subclasses will usually override this. return cls.port_name - def __init__(self, host, port_name=None, options=None, config=None, **kwargs): + def __init__(self, host, port_name=None, options=None, **kwargs): # This value may be different from cls.port_name by having version modifiers # and other fields appended to it (for example, 'qt-arm' or 'mac-wk2'). @@ -110,7 +111,8 @@ class Port(object): self.host = host self._executive = host.executive self._filesystem = host.filesystem - self._config = config or port_config.Config(self._executive, self._filesystem, self.port_name) + self._webkit_finder = WebKitFinder(host.filesystem) + self._config = port_config.Config(self._executive, self._filesystem, self.port_name) self._helper = None self._http_server = None @@ -571,7 +573,7 @@ class Port(object): reftest_list.append((expectation, path)) return reftest_list - return reftest_list.get(self._filesystem.join(self.layout_tests_dir(), test_name), []) + return reftest_list.get(self._filesystem.join(self.layout_tests_dir(), test_name), []) # pylint: disable-msg=E1103 def tests(self, paths): """Return the list of tests found. Both generic and platform-specific tests matching paths should be returned.""" @@ -683,17 +685,21 @@ class Port(object): """ self._filesystem.write_binary_file(baseline_path, data) - @memoized + # FIXME: update callers to create a finder and call it instead of these next five routines (which should be protected). + def webkit_base(self): + return self._webkit_finder.webkit_base() + + def path_from_webkit_base(self, *comps): + return self._webkit_finder.path_from_webkit_base(*comps) + + def path_to_script(self, script_name): + return self._webkit_finder.path_to_script(script_name) + def layout_tests_dir(self): - """Return the absolute path to the top of the LayoutTests directory.""" - return self._filesystem.normpath(self.path_from_webkit_base('LayoutTests')) + return self._webkit_finder.layout_tests_dir() def perf_tests_dir(self): - """Return the absolute path to the top of the PerformanceTests directory.""" - return self.path_from_webkit_base('PerformanceTests') - - def webkit_base(self): - return self._filesystem.abspath(self.path_from_webkit_base('.')) + return self._webkit_finder.perf_tests_dir() def skipped_layout_tests(self, test_list): """Returns tests skipped outside of the TestExpectations files.""" @@ -764,11 +770,6 @@ class Port(object): def set_option_default(self, name, default_value): return self._options.ensure_value(name, default_value) - def path_from_webkit_base(self, *comps): - """Returns the full path to path made by joining the top of the - WebKit source tree and the list of path components in |*comps|.""" - return self._config.path_from_webkit_base(*comps) - @memoized def path_to_test_expectations_file(self): """Update the test expectations to the passed-in string. @@ -1373,12 +1374,12 @@ class Port(object): return config_args def _run_script(self, script_name, args=None, include_configuration_arguments=True, decode_output=True, env=None): - run_script_command = [self._config.script_path(script_name)] + run_script_command = [self.path_to_script(script_name)] if include_configuration_arguments: run_script_command.extend(self._arguments_for_configuration()) if args: run_script_command.extend(args) - output = self._executive.run_command(run_script_command, cwd=self._config.webkit_base_dir(), decode_output=decode_output, env=env) + output = self._executive.run_command(run_script_command, cwd=self.webkit_base(), decode_output=decode_output, env=env) _log.debug('Output of %s:\n%s' % (run_script_command, output)) return output diff --git a/Tools/Scripts/webkitpy/layout_tests/port/base_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/base_unittest.py index 1fe75ccd4..77ef04a04 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/base_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/base_unittest.py @@ -45,9 +45,6 @@ from webkitpy.common.system.systemhost_mock import MockSystemHost from webkitpy.layout_tests.port import Port, Driver, DriverOutput from webkitpy.layout_tests.port.test import add_unit_tests_to_mock_filesystem, TestPort -import config -import config_mock - class PortTest(unittest.TestCase): def make_port(self, executive=None, with_tests=False, **kwargs): host = MockSystemHost() @@ -189,11 +186,6 @@ class PortTest(unittest.TestCase): self.assertTrue('act.txt' in diff) self.assertFalse('nosuchthing' in diff) - def test_default_configuration_notfound(self): - # Test that we delegate to the config object properly. - port = self.make_port(config=config_mock.MockConfig(default_configuration='default')) - self.assertEqual(port.default_configuration(), 'default') - def test_setup_test_run(self): port = self.make_port() # This routine is a no-op. We just test it for coverage. @@ -268,7 +260,7 @@ class PortTest(unittest.TestCase): port = self.make_port(port_name='foo') port.expectations_files = lambda: ['/mock-checkout/LayoutTests/platform/exists/TestExpectations', '/mock-checkout/LayoutTests/platform/nonexistant/TestExpectations'] port._filesystem.write_text_file('/mock-checkout/LayoutTests/platform/exists/TestExpectations', '') - self.assertEquals('\n'.join(port.expectations_dict().keys()), '/mock-checkout/LayoutTests/platform/exists/TestExpectations') + self.assertEqual('\n'.join(port.expectations_dict().keys()), '/mock-checkout/LayoutTests/platform/exists/TestExpectations') def test_additional_expectations(self): port = self.make_port(port_name='foo') @@ -279,19 +271,19 @@ class PortTest(unittest.TestCase): port._filesystem.write_text_file( '/tmp/additional-expectations-2.txt', 'content2\n') - self.assertEquals('\n'.join(port.expectations_dict().values()), '') + self.assertEqual('\n'.join(port.expectations_dict().values()), '') port._options.additional_expectations = [ '/tmp/additional-expectations-1.txt'] - self.assertEquals('\n'.join(port.expectations_dict().values()), '\ncontent1\n') + self.assertEqual('\n'.join(port.expectations_dict().values()), '\ncontent1\n') port._options.additional_expectations = [ '/tmp/nonexistent-file', '/tmp/additional-expectations-1.txt'] - self.assertEquals('\n'.join(port.expectations_dict().values()), '\ncontent1\n') + self.assertEqual('\n'.join(port.expectations_dict().values()), '\ncontent1\n') port._options.additional_expectations = [ '/tmp/additional-expectations-1.txt', '/tmp/additional-expectations-2.txt'] - self.assertEquals('\n'.join(port.expectations_dict().values()), '\ncontent1\n\ncontent2\n') + self.assertEqual('\n'.join(port.expectations_dict().values()), '\ncontent1\n\ncontent2\n') def test_additional_env_var(self): port = self.make_port(options=optparse.Values({'additional_env_var': ['FOO=BAR', 'BAR=FOO']})) diff --git a/Tools/Scripts/webkitpy/layout_tests/port/builders.py b/Tools/Scripts/webkitpy/layout_tests/port/builders.py index 155ac898b..380b5ad31 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/builders.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/builders.py @@ -58,8 +58,7 @@ _exact_matches = { "WebKit Mac10.6 (dbg)": {"port_name": "chromium-mac-snowleopard", "specifiers": set(["snowleopard", "debug"])}, "WebKit Mac10.7": {"port_name": "chromium-mac-lion", "specifiers": set(["lion", "release"])}, "WebKit Mac10.7 (dbg)": {"port_name": "chromium-mac-lion", "specifiers": set(["lion", "debug"])}, - "WebKit Mac10.8": {"port_name": "chromium-mac-mountainlion", "specifiers": set(["mountainlion", "release"]), - "move_overwritten_baselines_to": ["chromium-mac-lion"]}, + "WebKit Mac10.8": {"port_name": "chromium-mac-mountainlion", "specifiers": set(["mountainlion", "release"])}, # These builders are on build.webkit.org. "Apple MountainLion Release WK1 (Tests)": {"port_name": "mac-mountainlion", "specifiers": set(["mountainlion"]), "rebaseline_override_dir": "mac"}, @@ -83,8 +82,9 @@ _exact_matches = { # FIXME: Remove rebaseline_override_dir once there are Qt bots for all the platform/qt-* directories. "Qt Linux Release": {"port_name": "qt-linux", "specifiers": set(["win", "linux", "mac"]), "rebaseline_override_dir": "qt"}, - "EFL Linux 64-bit Debug": {"port_name": "efl", "specifiers": set(["efl", "debug"])}, "EFL Linux 64-bit Release": {"port_name": "efl", "specifiers": set(["efl", "release"])}, + "EFL Linux 64-bit Release WK2": {"port_name": "efl", "specifiers": set(["efl", "wk2", "release"])}, + "EFL Linux 64-bit Debug WK2": {"port_name": "efl", "specifiers": set(["efl", "wk2", "debug"])}, } diff --git a/Tools/Scripts/webkitpy/layout_tests/port/builders_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/builders_unittest.py index 1550df494..74320f2ad 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/builders_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/builders_unittest.py @@ -38,7 +38,7 @@ class BuildersTest(unittest.TestCase): '(.) ': '____', } for name, expected in tests.items(): - self.assertEquals(expected, builders.builder_path_from_name(name)) + self.assertEqual(expected, builders.builder_path_from_name(name)) if __name__ == '__main__': unittest.main() diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium.py index a69f5a822..4e0fbe282 100755 --- a/Tools/Scripts/webkitpy/layout_tests/port/chromium.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium.py @@ -77,6 +77,9 @@ class ChromiumPort(Port): DEFAULT_BUILD_DIRECTORIES = ('out',) + # overridden in subclasses. + FALLBACK_PATHS = {} + @classmethod def _static_build_path(cls, filesystem, build_directory, chromium_base, webkit_base, configuration, comps): if build_directory: diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_android.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_android.py index b8ac55ac1..2924f24e2 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_android.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_android.py @@ -354,10 +354,11 @@ class ChromiumAndroidDriver(driver.Driver): if self._has_setup: return + self._run_adb_command(['root']) self._setup_md5sum_and_push_data_if_needed() self._has_setup = True - self._run_adb_command(['root']) self._setup_performance() + # Required by webkit_support::GetWebKitRootDirFilePath(). # Other directories will be created automatically by adb push. self._run_adb_command(['shell', 'mkdir', '-p', DEVICE_SOURCE_ROOT_DIR + 'chrome']) @@ -488,10 +489,6 @@ class ChromiumAndroidDriver(driver.Driver): self._run_adb_command(['shell', 'echo', original_content, '>', file]) self._original_governors = {} - def _command_wrapper(cls, wrapper_option): - # Ignore command wrapper which is not applicable on Android. - return [] - def _get_crash_log(self, stdout, stderr, newer_than): if not stdout: stdout = '' diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_android_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_android_unittest.py index fce69c67d..856ac3151 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_android_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_android_unittest.py @@ -119,11 +119,11 @@ class ChromiumAndroidPortTest(chromium_port_testcase.ChromiumPortTestCase): def test_attributes(self): port = self.make_port() - self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-android')) + self.assertEqual(port.baseline_path(), port._webkit_baseline_path('chromium-android')) def test_default_timeout_ms(self): - self.assertEquals(self.make_port(options=optparse.Values({'configuration': 'Release'})).default_timeout_ms(), 10000) - self.assertEquals(self.make_port(options=optparse.Values({'configuration': 'Debug'})).default_timeout_ms(), 10000) + self.assertEqual(self.make_port(options=optparse.Values({'configuration': 'Release'})).default_timeout_ms(), 10000) + self.assertEqual(self.make_port(options=optparse.Values({'configuration': 'Debug'})).default_timeout_ms(), 10000) def test_expectations_files(self): # FIXME: override this test temporarily while we're still upstreaming the android port and @@ -138,14 +138,14 @@ class ChromiumAndroidPortTest(chromium_port_testcase.ChromiumPortTestCase): def test_get_devices_one_device(self): port = self.make_port() self.mock_run_command.mock_one_device() - self.assertEquals(self.mock_run_command._mock_devices, port._get_devices()) - self.assertEquals(1, port.default_child_processes()) + self.assertEqual(self.mock_run_command._mock_devices, port._get_devices()) + self.assertEqual(1, port.default_child_processes()) def test_get_devices_two_devices(self): port = self.make_port() self.mock_run_command.mock_two_devices() - self.assertEquals(self.mock_run_command._mock_devices, port._get_devices()) - self.assertEquals(2, port.default_child_processes()) + self.assertEqual(self.mock_run_command._mock_devices, port._get_devices()) + self.assertEqual(2, port.default_child_processes()) def test_get_device_serial_no_device(self): port = self.make_port() @@ -155,19 +155,19 @@ class ChromiumAndroidPortTest(chromium_port_testcase.ChromiumPortTestCase): def test_get_device_serial_one_device(self): port = self.make_port() self.mock_run_command.mock_one_device() - self.assertEquals(self.mock_run_command._mock_devices[0], port._get_device_serial(0)) + self.assertEqual(self.mock_run_command._mock_devices[0], port._get_device_serial(0)) self.assertRaises(AssertionError, port._get_device_serial, 1) def test_get_device_serial_two_devices(self): port = self.make_port() self.mock_run_command.mock_two_devices() - self.assertEquals(self.mock_run_command._mock_devices[0], port._get_device_serial(0)) - self.assertEquals(self.mock_run_command._mock_devices[1], port._get_device_serial(1)) + self.assertEqual(self.mock_run_command._mock_devices[0], port._get_device_serial(0)) + self.assertEqual(self.mock_run_command._mock_devices[1], port._get_device_serial(1)) self.assertRaises(AssertionError, port._get_device_serial, 2) def test_must_require_http_server(self): port = self.make_port() - self.assertEquals(port.requires_http_server(), True) + self.assertEqual(port.requires_http_server(), True) class ChromiumAndroidDriverTest(unittest.TestCase): @@ -181,13 +181,13 @@ class ChromiumAndroidDriverTest(unittest.TestCase): def test_get_last_stacktrace(self): self.mock_run_command.mock_no_tombstone_dir() - self.assertEquals(self.driver._get_last_stacktrace(), '') + self.assertEqual(self.driver._get_last_stacktrace(), '') self.mock_run_command.mock_no_tombstone_file() - self.assertEquals(self.driver._get_last_stacktrace(), '') + self.assertEqual(self.driver._get_last_stacktrace(), '') self.mock_run_command.mock_ten_tombstones() - self.assertEquals(self.driver._get_last_stacktrace(), + self.assertEqual(self.driver._get_last_stacktrace(), '-rw------- 1000 1000 45316 2012-04-27 16:33 tombstone_03\n' '/data/tombstones/tombstone_03\nmock_contents\n') @@ -196,7 +196,7 @@ class ChromiumAndroidDriverTest(unittest.TestCase): self.mock_run_command.mock_ten_tombstones() self.driver._crashed_process_name = 'foo' self.driver._crashed_pid = 1234 - self.assertEquals(self.driver._get_crash_log('out bar\nout baz\n', 'err bar\nerr baz\n', newer_than=None), + self.assertEqual(self.driver._get_crash_log('out bar\nout baz\n', 'err bar\nerr baz\n', newer_than=None), ('err bar\n' 'err baz\n' '********* [123456789ABCDEF0] Tombstone file:\n' @@ -217,7 +217,7 @@ class ChromiumAndroidDriverTest(unittest.TestCase): self.driver._crashed_process_name = None self.driver._crashed_pid = None - self.assertEquals(self.driver._get_crash_log(None, None, newer_than=None), + self.assertEqual(self.driver._get_crash_log(None, None, newer_than=None), ('********* [123456789ABCDEF0] Tombstone file:\n' '-rw------- 1000 1000 45316 2012-04-27 16:33 tombstone_03\n' '/data/tombstones/tombstone_03\n' @@ -232,7 +232,7 @@ class ChromiumAndroidDriverTest(unittest.TestCase): def test_cmd_line(self): cmd_line = self.driver.cmd_line(True, ['anything']) - self.assertEquals(['adb', '-s', self.mock_run_command._mock_devices[0], 'shell'], cmd_line) + self.assertEqual(['adb', '-s', self.mock_run_command._mock_devices[0], 'shell'], cmd_line) def test_drt_cmd_line(self): cmd_line = self.driver._drt_cmd_line(True, ['--a']) @@ -242,19 +242,19 @@ class ChromiumAndroidDriverTest(unittest.TestCase): def test_read_prompt(self): self.driver._server_process = driver_unittest.MockServerProcess(lines=['root@android:/ # ']) - self.assertEquals(self.driver._read_prompt(time.time() + 1), None) + self.assertEqual(self.driver._read_prompt(time.time() + 1), None) self.driver._server_process = driver_unittest.MockServerProcess(lines=['$ ']) - self.assertEquals(self.driver._read_prompt(time.time() + 1), None) + self.assertEqual(self.driver._read_prompt(time.time() + 1), None) def test_command_from_driver_input(self): driver_input = driver.DriverInput('foo/bar/test.html', 10, 'checksum', True) expected_command = "/data/local/tmp/third_party/WebKit/LayoutTests/foo/bar/test.html'--pixel-test'checksum\n" if (sys.platform != "cygwin"): - self.assertEquals(self.driver._command_from_driver_input(driver_input), expected_command) + self.assertEqual(self.driver._command_from_driver_input(driver_input), expected_command) driver_input = driver.DriverInput('http/tests/foo/bar/test.html', 10, 'checksum', True) expected_command = "http://127.0.0.1:8000/foo/bar/test.html'--pixel-test'checksum\n" - self.assertEquals(self.driver._command_from_driver_input(driver_input), expected_command) + self.assertEqual(self.driver._command_from_driver_input(driver_input), expected_command) class ChromiumAndroidDriverTwoDriversTest(unittest.TestCase): @@ -268,10 +268,10 @@ class ChromiumAndroidDriverTwoDriversTest(unittest.TestCase): driver1 = chromium_android.ChromiumAndroidDriver(port, worker_number=1, pixel_tests=True) cmd_line0 = driver0.cmd_line(True, ['anything']) - self.assertEquals(['adb', '-s', mock_run_command._mock_devices[0], 'shell'], cmd_line0) + self.assertEqual(['adb', '-s', mock_run_command._mock_devices[0], 'shell'], cmd_line0) cmd_line1 = driver1.cmd_line(True, ['anything']) - self.assertEquals(['adb', '-s', mock_run_command._mock_devices[1], 'shell'], cmd_line1) + self.assertEqual(['adb', '-s', mock_run_command._mock_devices[1], 'shell'], cmd_line1) class ChromiumAndroidTwoPortsTest(unittest.TestCase): @@ -286,8 +286,8 @@ class ChromiumAndroidTwoPortsTest(unittest.TestCase): MockSystemHost(executive=MockExecutive2(run_command_fn=mock_run_command.mock_run_command_fn)), 'chromium-android', options=options) cmd_line = port1.driver_cmd_line() - self.assertEquals(cmd_line.count('--encode-binary'), 1) - self.assertEquals(cmd_line.count('--enable-hardware-gpu'), 1) + self.assertEqual(cmd_line.count('--encode-binary'), 1) + self.assertEqual(cmd_line.count('--enable-hardware-gpu'), 1) if __name__ == '__main__': diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py index 7c37fd17a..dfacf9c08 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py @@ -29,6 +29,7 @@ import logging +from webkitpy.common.webkit_finder import WebKitFinder from webkitpy.layout_tests.port import chromium from webkitpy.layout_tests.port import config @@ -61,7 +62,7 @@ class ChromiumLinuxPort(chromium.ChromiumPort): def _determine_driver_path_statically(cls, host, options): config_object = config.Config(host.executive, host.filesystem) build_directory = getattr(options, 'build_directory', None) - webkit_base = config_object.path_from_webkit_base() + webkit_base = WebKitFinder(host.filesystem).webkit_base() chromium_base = cls._chromium_base_dir(host.filesystem) if hasattr(options, 'configuration') and options.configuration: configuration = options.configuration diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py index 169c2f4f4..4160034e3 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py @@ -47,7 +47,7 @@ class ChromiumLinuxPortTest(chromium_port_testcase.ChromiumPortTestCase): host.executive = executive_mock.MockExecutive2(file_output) port = self.make_port(host, port_name=port_name) - self.assertEquals(port.architecture(), expected_architecture) + self.assertEqual(port.architecture(), expected_architecture) if expected_architecture == 'x86': self.assertTrue(port.baseline_path().endswith('chromium-linux-x86')) self.assertTrue(port.baseline_search_path()[0].endswith('chromium-linux-x86')) @@ -74,14 +74,14 @@ class ChromiumLinuxPortTest(chromium_port_testcase.ChromiumPortTestCase): def test_determine_architecture_fails(self): # Test that we default to 'x86' if the driver doesn't exist. port = self.make_port() - self.assertEquals(port.architecture(), 'x86_64') + self.assertEqual(port.architecture(), 'x86_64') # Test that we default to 'x86' on an unknown architecture. host = MockSystemHost() host.filesystem.exists = lambda x: True host.executive = executive_mock.MockExecutive2('win32') port = self.make_port(host=host) - self.assertEquals(port.architecture(), 'x86_64') + self.assertEqual(port.architecture(), 'x86_64') # Test that we raise errors if something weird happens. host.executive = executive_mock.MockExecutive2(exception=AssertionError) @@ -112,7 +112,7 @@ class ChromiumLinuxPortTest(chromium_port_testcase.ChromiumPortTestCase): self.assertTrue(self.make_port(options=MockOptions(driver_name='OtherDriver'))._path_to_driver().endswith('OtherDriver')) def test_path_to_image_diff(self): - self.assertEquals(self.make_port()._path_to_image_diff(), '/mock-checkout/out/Release/ImageDiff') + self.assertEqual(self.make_port()._path_to_image_diff(), '/mock-checkout/out/Release/ImageDiff') if __name__ == '__main__': port_testcase.main() diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py index 21b7e317f..bd65cd1dc 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py @@ -92,14 +92,6 @@ class ChromiumMacPort(chromium.ChromiumPort): def operating_system(self): return 'mac' - def expectations_files(self): - # FIXME: This is a temporary hack while getting the 10.8 baselines up to date. - # See https://bugs.webkit.org/show_bug.cgi?id=99505 - files = super(ChromiumMacPort, self).expectations_files() - if self.name() == 'chromium-mac-mountainlion': - files.append(self._filesystem.join(self._webkit_baseline_path(self.name()), 'TestExpectations')) - return files - # # PROTECTED METHODS # diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py index b02af5ca1..d10326f0e 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py @@ -41,7 +41,7 @@ class ChromiumMacPortTest(chromium_port_testcase.ChromiumPortTestCase): def assert_name(self, port_name, os_version_string, expected): port = self.make_port(os_version=os_version_string, port_name=port_name) - self.assertEquals(expected, port.name()) + self.assertEqual(expected, port.name()) def test_versions(self): self.assertTrue(self.make_port().name() in ('chromium-mac-snowleopard', 'chromium-mac-lion', 'chromium-mac-mountainlion', 'chromium-mac-future')) @@ -64,16 +64,16 @@ class ChromiumMacPortTest(chromium_port_testcase.ChromiumPortTestCase): def test_baseline_path(self): port = self.make_port(port_name='chromium-mac-snowleopard') - self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-mac-snowleopard')) + self.assertEqual(port.baseline_path(), port._webkit_baseline_path('chromium-mac-snowleopard')) port = self.make_port(port_name='chromium-mac-lion') - self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-mac-lion')) + self.assertEqual(port.baseline_path(), port._webkit_baseline_path('chromium-mac-lion')) port = self.make_port(port_name='chromium-mac-mountainlion') - self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-mac')) + self.assertEqual(port.baseline_path(), port._webkit_baseline_path('chromium-mac')) port = self.make_port(port_name='chromium-mac-future') - self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-mac')) + self.assertEqual(port.baseline_path(), port._webkit_baseline_path('chromium-mac')) def test_operating_system(self): self.assertEqual('mac', self.make_port().operating_system()) @@ -100,11 +100,8 @@ class ChromiumMacPortTest(chromium_port_testcase.ChromiumPortTestCase): self.assertTrue(self.make_port(options=MockOptions(driver_name='OtherDriver'))._path_to_driver().endswith('OtherDriver')) def test_path_to_image_diff(self): - self.assertEquals(self.make_port()._path_to_image_diff(), '/mock-checkout/out/Release/ImageDiff') + self.assertEqual(self.make_port()._path_to_image_diff(), '/mock-checkout/out/Release/ImageDiff') - def test_ml_expectations(self): - self.assertTrue(self.make_port(port_name='chromium-mac-mountainlion').expectations_files()[-1].endswith('-mountainlion/TestExpectations')) - self.assertFalse(self.make_port(port_name='chromium-mac-lion').expectations_files()[-1].endswith('-mountainlion/TestExpectations')) if __name__ == '__main__': port_testcase.main() diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_port_testcase.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_port_testcase.py index a082a131c..dc5706beb 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_port_testcase.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_port_testcase.py @@ -51,16 +51,16 @@ class ChromiumPortTestCase(port_testcase.PortTestCase): def test_default_max_locked_shards(self): port = self.make_port() port.default_child_processes = lambda: 16 - self.assertEquals(port.default_max_locked_shards(), 4) + self.assertEqual(port.default_max_locked_shards(), 4) port.default_child_processes = lambda: 2 - self.assertEquals(port.default_max_locked_shards(), 1) + self.assertEqual(port.default_max_locked_shards(), 1) def test_default_timeout_ms(self): - self.assertEquals(self.make_port(options=MockOptions(configuration='Release')).default_timeout_ms(), 6000) - self.assertEquals(self.make_port(options=MockOptions(configuration='Debug')).default_timeout_ms(), 12000) + self.assertEqual(self.make_port(options=MockOptions(configuration='Release')).default_timeout_ms(), 6000) + self.assertEqual(self.make_port(options=MockOptions(configuration='Debug')).default_timeout_ms(), 12000) def test_default_pixel_tests(self): - self.assertEquals(self.make_port().default_pixel_tests(), True) + self.assertEqual(self.make_port().default_pixel_tests(), True) def test_missing_symbol_to_skipped_tests(self): # Test that we get the chromium skips and not the webkit default skips @@ -72,7 +72,7 @@ class ChromiumPortTestCase(port_testcase.PortTestCase): def test_all_test_configurations(self): """Validate the complete set of configurations this port knows about.""" port = self.make_port() - self.assertEquals(set(port.all_test_configurations()), set([ + self.assertEqual(set(port.all_test_configurations()), set([ TestConfiguration('icecreamsandwich', 'x86', 'debug'), TestConfiguration('icecreamsandwich', 'x86', 'release'), TestConfiguration('snowleopard', 'x86', 'debug'), @@ -103,7 +103,7 @@ class ChromiumPortTestCase(port_testcase.PortTestCase): class TestAndroidPort(chromium_android.ChromiumAndroidPort): def __init__(self, options=None): options = options or MockOptions() - chromium_win.ChromiumAndroidPort.__init__(self, MockSystemHost(os_name='android', os_version='icecreamsandwich'), 'chromium-android', options=options) + chromium_android.ChromiumAndroidPort.__init__(self, MockSystemHost(os_name='android', os_version='icecreamsandwich'), 'chromium-android', options=options) def default_configuration(self): self.default_configuration_called = True @@ -130,12 +130,12 @@ class ChromiumPortTestCase(port_testcase.PortTestCase): def test_default_configuration(self): mock_options = MockOptions() port = ChromiumPortTestCase.TestLinuxPort(options=mock_options) - self.assertEquals(mock_options.configuration, 'default') + self.assertEqual(mock_options.configuration, 'default') # pylint: disable-msg=E1101 self.assertTrue(port.default_configuration_called) mock_options = MockOptions(configuration=None) port = ChromiumPortTestCase.TestLinuxPort(mock_options) - self.assertEquals(mock_options.configuration, 'default') + self.assertEqual(mock_options.configuration, 'default') # pylint: disable-msg=E1101 self.assertTrue(port.default_configuration_called) def test_diff_image(self): @@ -152,11 +152,11 @@ class ChromiumPortTestCase(port_testcase.PortTestCase): # Images are different. port._executive = MockExecutive2(run_command_fn=mock_run_command) - self.assertEquals(mock_image_diff, port.diff_image("EXPECTED", "ACTUAL")[0]) + self.assertEqual(mock_image_diff, port.diff_image("EXPECTED", "ACTUAL")[0]) # Images are the same. port._executive = MockExecutive2(exit_code=0) - self.assertEquals(None, port.diff_image("EXPECTED", "ACTUAL")[0]) + self.assertEqual(None, port.diff_image("EXPECTED", "ACTUAL")[0]) # There was some error running image_diff. port._executive = MockExecutive2(exit_code=2) @@ -170,7 +170,7 @@ class ChromiumPortTestCase(port_testcase.PortTestCase): def test_diff_image_crashed(self): port = ChromiumPortTestCase.TestLinuxPort() port._executive = MockExecutive2(exit_code=2) - self.assertEquals(port.diff_image("EXPECTED", "ACTUAL"), (None, 0, 'image diff returned an exit code of 2')) + self.assertEqual(port.diff_image("EXPECTED", "ACTUAL"), (None, 0, 'image diff returned an exit code of 2')) def test_expectations_files(self): port = self.make_port() @@ -185,15 +185,15 @@ class ChromiumPortTestCase(port_testcase.PortTestCase): port._filesystem.write_text_file(skia_overrides_path, 'dummay text') port._options.builder_name = 'DUMMY_BUILDER_NAME' - self.assertEquals(port.expectations_files(), [expectations_path, skia_overrides_path, chromium_overrides_path]) + self.assertEqual(port.expectations_files(), [expectations_path, skia_overrides_path, chromium_overrides_path]) port._options.builder_name = 'builder (deps)' - self.assertEquals(port.expectations_files(), [expectations_path, skia_overrides_path, chromium_overrides_path]) + self.assertEqual(port.expectations_files(), [expectations_path, skia_overrides_path, chromium_overrides_path]) # A builder which does NOT observe the Chromium test_expectations, # but still observes the Skia test_expectations... port._options.builder_name = 'builder' - self.assertEquals(port.expectations_files(), [expectations_path, skia_overrides_path]) + self.assertEqual(port.expectations_files(), [expectations_path, skia_overrides_path]) def test_expectations_ordering(self): # since we don't implement self.port_name in ChromiumPort. diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_unittest.py index 87de41c6c..ac9bc90f6 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_unittest.py @@ -33,7 +33,6 @@ import unittest from webkitpy.common.system import logtesting from webkitpy.common.system.executive_mock import MockExecutive2 from webkitpy.common.system.systemhost_mock import MockSystemHost -from webkitpy.layout_tests.port.config_mock import MockConfig from webkitpy.thirdparty.mock import Mock from webkitpy.tool.mocktool import MockOptions diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py index dc184fc14..1c0ddc1fe 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py @@ -59,7 +59,7 @@ class ChromiumWinTest(chromium_port_testcase.ChromiumPortTestCase): def test_setup_environ_for_server_cygpath(self): port = self.make_port() env = port.setup_environ_for_server(port.driver_name()) - self.assertEquals(env['CYGWIN_PATH'], '/mock-checkout/Source/WebKit/chromium/third_party/cygwin/bin') + self.assertEqual(env['CYGWIN_PATH'], '/mock-checkout/Source/WebKit/chromium/third_party/cygwin/bin') def test_setup_environ_for_server_register_cygwin(self): port = self.make_port(options=MockOptions(register_cygwin=True, results_directory='/')) @@ -70,7 +70,7 @@ class ChromiumWinTest(chromium_port_testcase.ChromiumPortTestCase): def assert_name(self, port_name, os_version_string, expected): port = self.make_port(port_name=port_name, os_version=os_version_string) - self.assertEquals(expected, port.name()) + self.assertEqual(expected, port.name()) def test_versions(self): port = self.make_port() @@ -92,10 +92,10 @@ class ChromiumWinTest(chromium_port_testcase.ChromiumPortTestCase): def test_baseline_path(self): port = self.make_port(port_name='chromium-win-xp') - self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-win-xp')) + self.assertEqual(port.baseline_path(), port._webkit_baseline_path('chromium-win-xp')) port = self.make_port(port_name='chromium-win-win7') - self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-win')) + self.assertEqual(port.baseline_path(), port._webkit_baseline_path('chromium-win')) def test_build_path(self): # Test that optional paths are used regardless of whether they exist. @@ -122,4 +122,4 @@ class ChromiumWinTest(chromium_port_testcase.ChromiumPortTestCase): self.assertTrue(self.make_port(options=MockOptions(driver_name='OtherDriver'))._path_to_driver().endswith('OtherDriver.exe')) def test_path_to_image_diff(self): - self.assertEquals(self.make_port()._path_to_image_diff(), '/mock-checkout/out/Release/ImageDiff.exe') + self.assertEqual(self.make_port()._path_to_image_diff(), '/mock-checkout/out/Release/ImageDiff.exe') diff --git a/Tools/Scripts/webkitpy/layout_tests/port/config.py b/Tools/Scripts/webkitpy/layout_tests/port/config.py index dd8f331af..828e2af37 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/config.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/config.py @@ -29,14 +29,14 @@ """Wrapper objects for WebKit-specific utility routines.""" -# FIXME: This file needs to be unified with common/checkout/scm.py and -# common/config/ports.py . +# FIXME: This file needs to be unified with common/config/ports.py . -from webkitpy.common.system import logutils -from webkitpy.common.system import executive +import logging +from webkitpy.common import webkit_finder -_log = logutils.get_logger(__file__) + +_log = logging.getLogger(__name__) # # FIXME: This is used to record if we've already hit the filesystem to look @@ -64,7 +64,7 @@ class Config(object): def __init__(self, executive, filesystem, port_implementation=None): self._executive = executive self._filesystem = filesystem - self._webkit_base_dir = None + self._webkit_finder = webkit_finder.WebKitFinder(self._filesystem) self._default_configuration = None self._build_directories = {} self._port_implementation = port_implementation @@ -81,8 +81,8 @@ class Config(object): flags.append('--' + self._port_implementation) if not self._build_directories.get(configuration): - args = ["perl", self.script_path("webkit-build-directory")] + flags - output = self._executive.run_command(args, cwd=self.webkit_base_dir(), return_stderr=False).rstrip() + args = ["perl", self._webkit_finder.path_to_script("webkit-build-directory")] + flags + output = self._executive.run_command(args, cwd=self._webkit_finder.webkit_base(), return_stderr=False).rstrip() parts = output.split("\n") self._build_directories[configuration] = parts[0] @@ -111,32 +111,6 @@ class Config(object): _log.warn("Scripts may fail. See 'set-webkit-configuration --help'.") return self._default_configuration - def path_from_webkit_base(self, *comps): - return self._filesystem.join(self.webkit_base_dir(), *comps) - - # FIXME: We should only have one implementation of this logic, - # if scm.find_checkout_root() is broken for Chromium, we should fix (or at least wrap) it! - def webkit_base_dir(self): - """Returns the absolute path to the top of the WebKit tree. - - Raises an AssertionError if the top dir can't be determined.""" - # Note: this code somewhat duplicates the code in - # scm.find_checkout_root(). However, that code only works if the top - # of the SCM repository also matches the top of the WebKit tree. The - # Chromium ports, for example, only check out subdirectories like - # Tools/Scripts, and so we still have to do additional work - # to find the top of the tree. - # - # This code will also work if there is no SCM system at all. - if not self._webkit_base_dir: - config_module_path = self._filesystem.path_to_module(self.__module__) - self._webkit_base_dir = config_module_path[0:config_module_path.find('Tools') - 1] - return self._webkit_base_dir - - def script_path(self, script_name): - # This is intentionally relative. Callers should pass the checkout_root/webkit_base_dir to run_command as the cwd. - return self._filesystem.join("Tools", "Scripts", script_name) - def _determine_configuration(self): # This mirrors the logic in webkitdirs.pm:determineConfiguration(). # @@ -162,7 +136,7 @@ class Config(object): configuration_path = self._filesystem.join(self.build_directory(None), "Configuration") if not self._filesystem.exists(configuration_path): return None - except (OSError, executive.ScriptError): + except: return None return self._filesystem.read_text_file(configuration_path).rstrip() diff --git a/Tools/Scripts/webkitpy/layout_tests/port/config_mock.py b/Tools/Scripts/webkitpy/layout_tests/port/config_mock.py deleted file mode 100644 index 5476e4bab..000000000 --- a/Tools/Scripts/webkitpy/layout_tests/port/config_mock.py +++ /dev/null @@ -1,67 +0,0 @@ -#!/usr/bin/env python -# Copyright (C) 2010 Google Inc. All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: -# -# * Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# * Redistributions in binary form must reproduce the above -# copyright notice, this list of conditions and the following disclaimer -# in the documentation and/or other materials provided with the -# distribution. -# * Neither the name of Google Inc. nor the names of its -# contributors may be used to endorse or promote products derived from -# this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -"""Wrapper objects for WebKit-specific utility routines.""" - -from webkitpy.common.system.filesystem_mock import MockFileSystem - - -class MockConfig(object): - _FLAGS_FROM_CONFIGURATIONS = { - "Debug": "--debug", - "Release": "--release", - } - - def __init__(self, filesystem=None, default_configuration='Release', port_implementation=None): - self._filesystem = filesystem or MockFileSystem() - self._default_configuration = default_configuration - self._port_implmentation = port_implementation - - def flag_for_configuration(self, configuration): - return self._FLAGS_FROM_CONFIGURATIONS[configuration] - - def build_directory(self, configuration): - return "/mock-build" - - def build_dumprendertree(self, configuration): - return True - - def default_configuration(self): - return self._default_configuration - - def path_from_webkit_base(self, *comps): - # FIXME: This could use self._filesystem.join, but that doesn't handle empty lists. - return self.webkit_base_dir() + "/" + "/".join(list(comps)) - - def script_path(self, script_name): - # This is intentionally relative. Callers should pass the checkout_root/webkit_base_dir to run_command as the cwd. - return self._filesystem.join("Tools", "Scripts", script_name) - - def webkit_base_dir(self): - return "/mock-checkout" diff --git a/Tools/Scripts/webkitpy/layout_tests/port/config_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/config_unittest.py index 96ba5ff58..4479204ad 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/config_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/config_unittest.py @@ -31,10 +31,11 @@ import sys import unittest from webkitpy.common.system.executive import Executive, ScriptError -from webkitpy.common.system.executive_mock import MockExecutive, MockExecutive2 +from webkitpy.common.system.executive_mock import MockExecutive2 from webkitpy.common.system.filesystem import FileSystem from webkitpy.common.system.filesystem_mock import MockFileSystem from webkitpy.common.system.outputcapture import OutputCapture +from webkitpy.common.webkit_finder import WebKitFinder import config @@ -131,12 +132,11 @@ class ConfigTest(unittest.TestCase): e = Executive() fs = FileSystem() c = config.Config(e, fs) - script = c.path_from_webkit_base('Tools', 'Scripts', 'webkitpy', 'layout_tests', 'port', 'config_standalone.py') + script = WebKitFinder(fs).path_from_webkit_base('Tools', 'Scripts', 'webkitpy', 'layout_tests', 'port', 'config_standalone.py') # Note: don't use 'Release' here, since that's the normal default. expected = 'Debug' - # FIXME: Why are we running a python subprocess here?? args = [sys.executable, script, '--mock', expected] actual = e.run_command(args).rstrip() self.assertEqual(actual, expected) @@ -157,32 +157,6 @@ class ConfigTest(unittest.TestCase): actual = c.default_configuration() self.assertEqual(actual, 'Release') - def test_path_from_webkit_base(self): - c = config.Config(MockExecutive(), MockFileSystem()) - self.assertTrue(c.path_from_webkit_base('foo')) - - def test_webkit_base_dir(self): - # FIXME: We use a real filesystem here. Should this move to a mocked one? - executive = Executive() - filesystem = FileSystem() - c = config.Config(executive, filesystem) - base_dir = c.webkit_base_dir() - self.assertTrue(base_dir) - self.assertNotEqual(base_dir[-1], '/') - - # FIXME: Once we use a MockFileSystem for this test we don't need to save the orig_cwd. - orig_cwd = filesystem.getcwd() - if sys.platform == 'win32': - filesystem.chdir(os.environ['USERPROFILE']) - else: - filesystem.chdir(os.environ['HOME']) - c = config.Config(executive, filesystem) - try: - base_dir_2 = c.webkit_base_dir() - self.assertEqual(base_dir, base_dir_2) - finally: - filesystem.chdir(orig_cwd) - if __name__ == '__main__': unittest.main() diff --git a/Tools/Scripts/webkitpy/layout_tests/port/driver_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/driver_unittest.py index 5b11ade2a..6a5481f6a 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/driver_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/driver_unittest.py @@ -36,6 +36,8 @@ from webkitpy.layout_tests.port.server_process_mock import MockServerProcess # FIXME: remove the dependency on TestWebKitPort from webkitpy.layout_tests.port.port_testcase import TestWebKitPort +from webkitpy.tool.mocktool import MockOptions + class DriverOutputTest(unittest.TestCase): def test_strip_metrics(self): @@ -80,7 +82,9 @@ class DriverOutputTest(unittest.TestCase): class DriverTest(unittest.TestCase): def make_port(self): - return Port(MockSystemHost()) + port = Port(MockSystemHost(), MockOptions(configuration='Release')) + port._config.build_directory = lambda configuration: '/mock-build' + return port def _assert_wrapper(self, wrapper_string, expected_wrapper): wrapper = Driver(self.make_port(), None, pixel_tests=False)._command_wrapper(wrapper_string) @@ -119,9 +123,9 @@ class DriverTest(unittest.TestCase): "#EOF", ]) content_block = driver._read_block(0) - self.assertEquals(content_block.content_type, 'my_type') - self.assertEquals(content_block.encoding, 'none') - self.assertEquals(content_block.content_hash, 'foobar') + self.assertEqual(content_block.content_type, 'my_type') + self.assertEqual(content_block.encoding, 'none') + self.assertEqual(content_block.content_hash, 'foobar') driver._server_process = None def test_read_binary_block(self): @@ -136,10 +140,10 @@ class DriverTest(unittest.TestCase): "#EOF", ]) content_block = driver._read_block(0) - self.assertEquals(content_block.content_type, 'image/png') - self.assertEquals(content_block.content_hash, 'actual') - self.assertEquals(content_block.content, '12345678\n') - self.assertEquals(content_block.decoded_content, '12345678\n') + self.assertEqual(content_block.content_type, 'image/png') + self.assertEqual(content_block.content_hash, 'actual') + self.assertEqual(content_block.content, '12345678\n') + self.assertEqual(content_block.decoded_content, '12345678\n') driver._server_process = None def test_read_base64_block(self): @@ -154,16 +158,17 @@ class DriverTest(unittest.TestCase): 'MTIzNDU2NzgK#EOF', ]) content_block = driver._read_block(0) - self.assertEquals(content_block.content_type, 'image/png') - self.assertEquals(content_block.content_hash, 'actual') - self.assertEquals(content_block.encoding, 'base64') - self.assertEquals(content_block.content, 'MTIzNDU2NzgK') - self.assertEquals(content_block.decoded_content, '12345678\n') + self.assertEqual(content_block.content_type, 'image/png') + self.assertEqual(content_block.content_hash, 'actual') + self.assertEqual(content_block.encoding, 'base64') + self.assertEqual(content_block.content, 'MTIzNDU2NzgK') + self.assertEqual(content_block.decoded_content, '12345678\n') def test_no_timeout(self): port = TestWebKitPort() + port._config.build_directory = lambda configuration: '/mock-build' driver = Driver(port, 0, pixel_tests=True, no_timeout=True) - self.assertEquals(driver.cmd_line(True, []), ['/mock-build/DumpRenderTree', '--no-timeout', '-']) + self.assertEqual(driver.cmd_line(True, []), ['/mock-build/DumpRenderTree', '--no-timeout', '-']) def test_check_for_driver_crash(self): port = TestWebKitPort() @@ -186,10 +191,10 @@ class DriverTest(unittest.TestCase): pass def assert_crash(driver, error_line, crashed, name, pid, unresponsive=False): - self.assertEquals(driver._check_for_driver_crash(error_line), crashed) - self.assertEquals(driver._crashed_process_name, name) - self.assertEquals(driver._crashed_pid, pid) - self.assertEquals(driver._subprocess_was_unresponsive, unresponsive) + self.assertEqual(driver._check_for_driver_crash(error_line), crashed) + self.assertEqual(driver._crashed_process_name, name) + self.assertEqual(driver._crashed_pid, pid) + self.assertEqual(driver._subprocess_was_unresponsive, unresponsive) driver.stop() driver._server_process = FakeServerProcess(False) @@ -234,8 +239,8 @@ class DriverTest(unittest.TestCase): def test_creating_a_port_does_not_write_to_the_filesystem(self): port = TestWebKitPort() driver = Driver(port, 0, pixel_tests=True) - self.assertEquals(port._filesystem.written_files, {}) - self.assertEquals(port._filesystem.last_tmpdir, None) + self.assertEqual(port._filesystem.written_files, {}) + self.assertEqual(port._filesystem.last_tmpdir, None) def test_stop_cleans_up_properly(self): port = TestWebKitPort() diff --git a/Tools/Scripts/webkitpy/layout_tests/port/factory_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/factory_unittest.py index 2980c2d23..915c17d89 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/factory_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/factory_unittest.py @@ -105,7 +105,7 @@ class FactoryTest(unittest.TestCase): self.assertRaises(NotImplementedError, factory.PortFactory(MockSystemHost(os_name='vms')).get) def test_get_from_builder_name(self): - self.assertEquals(factory.PortFactory(MockSystemHost()).get_from_builder_name('WebKit Mac10.7').name(), + self.assertEqual(factory.PortFactory(MockSystemHost()).get_from_builder_name('WebKit Mac10.7').name(), 'chromium-mac-lion') diff --git a/Tools/Scripts/webkitpy/layout_tests/port/gtk.py b/Tools/Scripts/webkitpy/layout_tests/port/gtk.py index 3d820274e..2ec7d70c4 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/gtk.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/gtk.py @@ -71,9 +71,7 @@ class GtkPort(Port, PulseAudioSanitizer): environment['TEST_RUNNER_INJECTED_BUNDLE_FILENAME'] = self._build_path('Libraries', 'libTestRunnerInjectedBundle.la') environment['TEST_RUNNER_TEST_PLUGIN_PATH'] = self._build_path('TestNetscapePlugin', '.libs') environment['WEBKIT_INSPECTOR_PATH'] = self._build_path('Programs', 'resources', 'inspector') - environment['AUDIO_RESOURCES_PATH'] = self._filesystem.join(self._config.webkit_base_dir(), - 'Source', 'WebCore', 'platform', - 'audio', 'resources') + environment['AUDIO_RESOURCES_PATH'] = self.path_from_webkit_base('Source', 'WebCore', 'platform', 'audio', 'resources') self._copy_value_from_environ_if_set(environment, 'WEBKITOUTPUTDIR') return environment diff --git a/Tools/Scripts/webkitpy/layout_tests/port/gtk_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/gtk_unittest.py index f1df6bfa1..6f5fae68d 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/gtk_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/gtk_unittest.py @@ -50,10 +50,10 @@ class GtkPortTest(port_testcase.PortTestCase): OutputCapture().assert_outputs(self, port.show_results_html_file, ["test.html"], expected_stderr=expected_stderr) def test_default_timeout_ms(self): - self.assertEquals(self.make_port(options=MockOptions(configuration='Release')).default_timeout_ms(), 6000) - self.assertEquals(self.make_port(options=MockOptions(configuration='Debug')).default_timeout_ms(), 12000) - self.assertEquals(self.make_port(options=MockOptions(webkit_test_runner=True, configuration='Debug')).default_timeout_ms(), 80000) - self.assertEquals(self.make_port(options=MockOptions(webkit_test_runner=True, configuration='Release')).default_timeout_ms(), 80000) + self.assertEqual(self.make_port(options=MockOptions(configuration='Release')).default_timeout_ms(), 6000) + self.assertEqual(self.make_port(options=MockOptions(configuration='Debug')).default_timeout_ms(), 12000) + self.assertEqual(self.make_port(options=MockOptions(webkit_test_runner=True, configuration='Debug')).default_timeout_ms(), 80000) + self.assertEqual(self.make_port(options=MockOptions(webkit_test_runner=True, configuration='Release')).default_timeout_ms(), 80000) def assertLinesEqual(self, a, b): if hasattr(self, 'assertMultiLineEqual'): diff --git a/Tools/Scripts/webkitpy/layout_tests/port/http_lock_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/http_lock_unittest.py index fbf2d9df3..650a7670f 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/http_lock_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/http_lock_unittest.py @@ -88,7 +88,7 @@ class HttpLockTest(unittest.TestCase): # FIXME: Once Executive wraps getpid, we can mock this and not use a real pid. current_pid = os.getpid() self.http_lock._filesystem.write_text_file(self.lock_file_name, str(current_pid)) - self.assertEquals(self.http_lock._current_lock_pid(), current_pid) + self.assertEqual(self.http_lock._current_lock_pid(), current_pid) def test_extract_lock_number(self): lock_file_list = ( diff --git a/Tools/Scripts/webkitpy/layout_tests/port/image_diff_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/image_diff_unittest.py index 46cc98a11..0e5f0a0ff 100755 --- a/Tools/Scripts/webkitpy/layout_tests/port/image_diff_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/image_diff_unittest.py @@ -49,9 +49,9 @@ class TestImageDiffer(unittest.TestCase): def test_diff_image_failed(self): port = FakePort(['diff: 100% failed\n']) image_differ = ImageDiffer(port) - self.assertEquals(image_differ.diff_image('foo', 'bar', 0.1), ('', 100.0, None)) + self.assertEqual(image_differ.diff_image('foo', 'bar', 0.1), ('', 100.0, None)) def test_diff_image_passed(self): port = FakePort(['diff: 0% passed\n']) image_differ = ImageDiffer(port) - self.assertEquals(image_differ.diff_image('foo', 'bar', 0.1), (None, 0, None)) + self.assertEqual(image_differ.diff_image('foo', 'bar', 0.1), (None, 0, None)) diff --git a/Tools/Scripts/webkitpy/layout_tests/port/leakdetector_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/leakdetector_unittest.py index 7628bb709..09d37d711 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/leakdetector_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/leakdetector_unittest.py @@ -51,7 +51,7 @@ class LeakDetectorTest(unittest.TestCase): detector._callstacks_to_exclude_from_leaks = lambda: ['foo bar', 'BAZ'] detector._types_to_exlude_from_leaks = lambda: ['abcdefg', 'hi jklmno'] expected_args = ['--exclude-callstack=foo bar', '--exclude-callstack=BAZ', '--exclude-type=abcdefg', '--exclude-type=hi jklmno', 1234] - self.assertEquals(detector._leaks_args(1234), expected_args) + self.assertEqual(detector._leaks_args(1234), expected_args) example_leaks_output = """Process 5122: 663744 nodes malloced for 78683 KB Process 5122: 337301 leaks for 6525216 total leaked bytes. @@ -110,18 +110,18 @@ Binary Images: """ def test_parse_leaks_output(self): - self.assertEquals(self._make_detector()._parse_leaks_output(self.example_leaks_output), (337301, 0, 6525216)) - self.assertEquals(self._make_detector()._parse_leaks_output(self.example_leaks_output_with_exclusions), (282, 17, 21920)) + self.assertEqual(self._make_detector()._parse_leaks_output(self.example_leaks_output), (337301, 0, 6525216)) + self.assertEqual(self._make_detector()._parse_leaks_output(self.example_leaks_output_with_exclusions), (282, 17, 21920)) def test_leaks_files_in_directory(self): detector = self._make_detector() - self.assertEquals(detector.leaks_files_in_directory('/bogus-directory'), []) + self.assertEqual(detector.leaks_files_in_directory('/bogus-directory'), []) detector._filesystem = MockFileSystem({ '/mock-results/DumpRenderTree-1234-leaks.txt': '', '/mock-results/DumpRenderTree-23423-leaks.txt': '', '/mock-results/DumpRenderTree-823-leaks.txt': '', }) - self.assertEquals(len(detector.leaks_files_in_directory('/mock-results')), 3) + self.assertEqual(len(detector.leaks_files_in_directory('/mock-results')), 3) def test_count_total_bytes_and_unique_leaks(self): detector = self._make_detector() @@ -138,7 +138,7 @@ total: 5,888 bytes (0 bytes excluded).""" leak_files = ['/mock-results/DumpRenderTree-1234-leaks.txt', '/mock-results/DumpRenderTree-1235-leaks.txt'] expected_stdout = "MOCK _run_script: parse-malloc-history ['--merge-depth', 5, '/mock-results/DumpRenderTree-1234-leaks.txt', '/mock-results/DumpRenderTree-1235-leaks.txt']\n" results_tuple = OutputCapture().assert_outputs(self, detector.count_total_bytes_and_unique_leaks, [leak_files], expected_stdout=expected_stdout) - self.assertEquals(results_tuple, ("5,888 bytes", 2)) + self.assertEqual(results_tuple, ("5,888 bytes", 2)) def test_count_total_leaks(self): detector = self._make_detector() @@ -149,4 +149,4 @@ total: 5,888 bytes (0 bytes excluded).""" '/mock-results/DumpRenderTree-823-leaks.txt': 'Process 12356: 23412 leaks for 18 total leaked bytes.\n', }) leak_file_paths = ['/mock-results/DumpRenderTree-1234-leaks.txt', '/mock-results/DumpRenderTree-23423-leaks.txt', '/mock-results/DumpRenderTree-823-leaks.txt'] - self.assertEquals(detector.count_total_leaks(leak_file_paths), 35765) + self.assertEqual(detector.count_total_leaks(leak_file_paths), 35765) diff --git a/Tools/Scripts/webkitpy/layout_tests/port/mac.py b/Tools/Scripts/webkitpy/layout_tests/port/mac.py index e6fd5bd3c..4415b8a62 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/mac.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/mac.py @@ -168,8 +168,8 @@ class MacPort(ApplePort): # We don't use self._run_script() because we don't want to wait for the script # to exit and we want the output to show up on stdout in case there are errors # launching the browser. - self._executive.popen([self._config.script_path('run-safari')] + self._arguments_for_configuration() + ['--no-saved-state', '-NSOpen', results_filename], - cwd=self._config.webkit_base_dir(), stdout=file(os.devnull), stderr=file(os.devnull)) + self._executive.popen([self.path_to_script('run-safari')] + self._arguments_for_configuration() + ['--no-saved-state', '-NSOpen', results_filename], + cwd=self.webkit_base(), stdout=file(os.devnull), stderr=file(os.devnull)) # FIXME: The next two routines turn off the http locking in order # to work around failures on the bots caused when the slave restarts. diff --git a/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py index c2b26b2f7..511201464 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py @@ -47,7 +47,7 @@ class MacTest(port_testcase.PortTestCase): def test_default_timeout_ms(self): super(MacTest, self).test_default_timeout_ms() - self.assertEquals(self.make_port(options=MockOptions(guard_malloc=True)).default_timeout_ms(), 350000) + self.assertEqual(self.make_port(options=MockOptions(guard_malloc=True)).default_timeout_ms(), 350000) example_skipped_file = u""" @@ -77,7 +77,7 @@ java/ def assert_name(self, port_name, os_version_string, expected): host = MockSystemHost(os_name='mac', os_version=os_version_string) port = self.make_port(host=host, port_name=port_name) - self.assertEquals(expected, port.name()) + self.assertEqual(expected, port.name()) def test_tests_for_other_platforms(self): platforms = ['mac', 'chromium-linux', 'mac-snowleopard'] @@ -115,14 +115,14 @@ java/ def test_setup_environ_for_server(self): port = self.make_port(options=MockOptions(leaks=True, guard_malloc=True)) env = port.setup_environ_for_server(port.driver_name()) - self.assertEquals(env['MallocStackLogging'], '1') - self.assertEquals(env['DYLD_INSERT_LIBRARIES'], '/usr/lib/libgmalloc.dylib') + self.assertEqual(env['MallocStackLogging'], '1') + self.assertEqual(env['DYLD_INSERT_LIBRARIES'], '/usr/lib/libgmalloc.dylib') def _assert_search_path(self, port_name, baseline_path, search_paths, use_webkit2=False): port = self.make_port(port_name=port_name, options=MockOptions(webkit_test_runner=use_webkit2)) absolute_search_paths = map(port._webkit_baseline_path, search_paths) - self.assertEquals(port.baseline_path(), port._webkit_baseline_path(baseline_path)) - self.assertEquals(port.baseline_search_path(), absolute_search_paths) + self.assertEqual(port.baseline_path(), port._webkit_baseline_path(baseline_path)) + self.assertEqual(port.baseline_search_path(), absolute_search_paths) def test_baseline_search_path(self): # Note that we don't need total coverage here, just path coverage, since this is all data driven. @@ -240,18 +240,18 @@ java/ self.args = args port._run_script = run_script - self.assertEquals(port.architecture(), 'x86') + self.assertEqual(port.architecture(), 'x86') port._build_driver() - self.assertEquals(self.args, ['ARCHS=i386']) + self.assertEqual(self.args, ['ARCHS=i386']) def test_64bit(self): # Apple Mac port is 64-bit by default port = self.make_port() - self.assertEquals(port.architecture(), 'x86_64') + self.assertEqual(port.architecture(), 'x86_64') def run_script(script, args=None, env=None): self.args = args port._run_script = run_script port._build_driver() - self.assertEquals(self.args, []) + self.assertEqual(self.args, []) diff --git a/Tools/Scripts/webkitpy/layout_tests/port/mock_drt_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/mock_drt_unittest.py index 1ac051abd..c4c43f5d8 100755 --- a/Tools/Scripts/webkitpy/layout_tests/port/mock_drt_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/mock_drt_unittest.py @@ -257,7 +257,7 @@ class MockTestShellTest(MockDRTTest): '\n', '#EOF\n'], host=host) - self.assertEquals(host.filesystem.written_files, + self.assertEqual(host.filesystem.written_files, {'/tmp/png_result0.png': 'image_checksum\x8a-pngtEXtchecksum\x00image_checksum-checksum'}) def test_test_shell_parse_options(self): @@ -265,4 +265,4 @@ class MockTestShellTest(MockDRTTest): '--pixel-tests=/tmp/png_result0.png']) self.assertTrue(options.test_shell) self.assertTrue(options.pixel_tests) - self.assertEquals(options.pixel_path, '/tmp/png_result0.png') + self.assertEqual(options.pixel_path, '/tmp/png_result0.png') diff --git a/Tools/Scripts/webkitpy/layout_tests/port/port_testcase.py b/Tools/Scripts/webkitpy/layout_tests/port/port_testcase.py index b036f4b0d..e7cd76c92 100755 --- a/Tools/Scripts/webkitpy/layout_tests/port/port_testcase.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/port_testcase.py @@ -41,7 +41,6 @@ from webkitpy.common.system.filesystem_mock import MockFileSystem from webkitpy.common.system.outputcapture import OutputCapture from webkitpy.common.system.systemhost_mock import MockSystemHost from webkitpy.layout_tests.port.base import Port -from webkitpy.layout_tests.port.config_mock import MockConfig from webkitpy.layout_tests.port.server_process_mock import MockServerProcess from webkitpy.layout_tests.servers import http_server_base from webkitpy.tool.mocktool import MockOptions @@ -56,8 +55,7 @@ class TestWebKitPort(Port): **kwargs): self.symbols_string = symbols_string # Passing "" disables all staticly-detectable features. host = host or MockSystemHost() - config = config or MockConfig() - super(TestWebKitPort, self).__init__(host=host, config=config, **kwargs) + super(TestWebKitPort, self).__init__(host=host, **kwargs) def all_test_configurations(self): return [self.test_configuration()] @@ -81,28 +79,30 @@ class PortTestCase(unittest.TestCase): os_name = None os_version = None port_maker = TestWebKitPort + port_name = None - def make_port(self, host=None, port_name=None, options=None, os_name=None, os_version=None, config=None, **kwargs): + def make_port(self, host=None, port_name=None, options=None, os_name=None, os_version=None, **kwargs): host = host or MockSystemHost(os_name=(os_name or self.os_name), os_version=(os_version or self.os_version)) options = options or MockOptions(configuration='Release') - config = config or MockConfig(filesystem=host.filesystem, default_configuration='Release') port_name = port_name or self.port_name port_name = self.port_maker.determine_full_port_name(host, options, port_name) - return self.port_maker(host, port_name, options=options, config=config, **kwargs) + port = self.port_maker(host, port_name, options=options, **kwargs) + port._config.build_directory = lambda configuration: '/mock-build' + return port def test_default_max_locked_shards(self): port = self.make_port() port.default_child_processes = lambda: 16 - self.assertEquals(port.default_max_locked_shards(), 1) + self.assertEqual(port.default_max_locked_shards(), 1) port.default_child_processes = lambda: 2 - self.assertEquals(port.default_max_locked_shards(), 1) + self.assertEqual(port.default_max_locked_shards(), 1) def test_default_timeout_ms(self): - self.assertEquals(self.make_port(options=MockOptions(configuration='Release')).default_timeout_ms(), 35000) - self.assertEquals(self.make_port(options=MockOptions(configuration='Debug')).default_timeout_ms(), 35000) + self.assertEqual(self.make_port(options=MockOptions(configuration='Release')).default_timeout_ms(), 35000) + self.assertEqual(self.make_port(options=MockOptions(configuration='Debug')).default_timeout_ms(), 35000) def test_default_pixel_tests(self): - self.assertEquals(self.make_port().default_pixel_tests(), False) + self.assertEqual(self.make_port().default_pixel_tests(), False) def test_driver_cmd_line(self): port = self.make_port() @@ -114,9 +114,6 @@ class PortTestCase(unittest.TestCase): self.assertTrue('--foo=bar' in cmd_line) self.assertTrue('--foo=baz' in cmd_line) - def test_expectations_files(self): - self.assertNotEquals(self.make_port().expectations_files(), []) - def test_uses_apache(self): self.assertTrue(self.make_port()._uses_apache()) @@ -270,18 +267,18 @@ class PortTestCase(unittest.TestCase): port._server_process_constructor = make_proc port.setup_test_run() - self.assertEquals(port.diff_image('foo', 'bar'), ('', 100.0, None)) - self.assertEquals(self.proc.cmd[1:3], ["--tolerance", "0.1"]) + self.assertEqual(port.diff_image('foo', 'bar'), ('', 100.0, None)) + self.assertEqual(self.proc.cmd[1:3], ["--tolerance", "0.1"]) - self.assertEquals(port.diff_image('foo', 'bar', None), ('', 100.0, None)) - self.assertEquals(self.proc.cmd[1:3], ["--tolerance", "0.1"]) + self.assertEqual(port.diff_image('foo', 'bar', None), ('', 100.0, None)) + self.assertEqual(self.proc.cmd[1:3], ["--tolerance", "0.1"]) - self.assertEquals(port.diff_image('foo', 'bar', 0), ('', 100.0, None)) - self.assertEquals(self.proc.cmd[1:3], ["--tolerance", "0"]) + self.assertEqual(port.diff_image('foo', 'bar', 0), ('', 100.0, None)) + self.assertEqual(self.proc.cmd[1:3], ["--tolerance", "0"]) port.clean_up_test_run() self.assertTrue(self.proc.stopped) - self.assertEquals(port._image_differ, None) + self.assertEqual(port._image_differ, None) def test_diff_image_crashed(self): port = self.make_port() @@ -293,7 +290,7 @@ class PortTestCase(unittest.TestCase): port._server_process_constructor = make_proc port.setup_test_run() - self.assertEquals(port.diff_image('foo', 'bar'), ('', 0, 'ImageDiff crashed\n')) + self.assertEqual(port.diff_image('foo', 'bar'), ('', 0, 'ImageDiff crashed\n')) port.clean_up_test_run() def test_check_wdiff(self): @@ -389,13 +386,13 @@ class PortTestCase(unittest.TestCase): def test_get_crash_log(self): port = self.make_port() - self.assertEquals(port._get_crash_log(None, None, None, None, newer_than=None), + self.assertEqual(port._get_crash_log(None, None, None, None, newer_than=None), (None, 'crash log for <unknown process name> (pid <unknown>):\n' 'STDOUT: <empty>\n' 'STDERR: <empty>\n')) - self.assertEquals(port._get_crash_log('foo', 1234, 'out bar\nout baz', 'err bar\nerr baz\n', newer_than=None), + self.assertEqual(port._get_crash_log('foo', 1234, 'out bar\nout baz', 'err bar\nerr baz\n', newer_than=None), ('err bar\nerr baz\n', 'crash log for foo (pid 1234):\n' 'STDOUT: out bar\n' @@ -403,13 +400,13 @@ class PortTestCase(unittest.TestCase): 'STDERR: err bar\n' 'STDERR: err baz\n')) - self.assertEquals(port._get_crash_log('foo', 1234, 'foo\xa6bar', 'foo\xa6bar', newer_than=None), + self.assertEqual(port._get_crash_log('foo', 1234, 'foo\xa6bar', 'foo\xa6bar', newer_than=None), ('foo\xa6bar', u'crash log for foo (pid 1234):\n' u'STDOUT: foo\ufffdbar\n' u'STDERR: foo\ufffdbar\n')) - self.assertEquals(port._get_crash_log('foo', 1234, 'foo\xa6bar', 'foo\xa6bar', newer_than=1.0), + self.assertEqual(port._get_crash_log('foo', 1234, 'foo\xa6bar', 'foo\xa6bar', newer_than=1.0), ('foo\xa6bar', u'crash log for foo (pid 1234):\n' u'STDOUT: foo\ufffdbar\n' @@ -419,14 +416,14 @@ class PortTestCase(unittest.TestCase): port = self.make_port(options=options) for directory in dirs: port.host.filesystem.maybe_make_directory(directory) - self.assertEquals(port._build_path(), expected_path) + self.assertEqual(port._build_path(), expected_path) def test_expectations_ordering(self): port = self.make_port() for path in port.expectations_files(): port._filesystem.write_text_file(path, '') ordered_dict = port.expectations_dict() - self.assertEquals(port.path_to_test_expectations_file(), ordered_dict.keys()[0]) + self.assertEqual(port.path_to_test_expectations_file(), ordered_dict.keys()[0]) options = MockOptions(additional_expectations=['/tmp/foo', '/tmp/bar']) port = self.make_port(options=options) @@ -435,8 +432,8 @@ class PortTestCase(unittest.TestCase): port._filesystem.write_text_file('/tmp/foo', 'foo') port._filesystem.write_text_file('/tmp/bar', 'bar') ordered_dict = port.expectations_dict() - self.assertEquals(ordered_dict.keys()[-2:], options.additional_expectations) - self.assertEquals(ordered_dict.values()[-2:], ['foo', 'bar']) + self.assertEqual(ordered_dict.keys()[-2:], options.additional_expectations) # pylint: disable-msg=E1101 + self.assertEqual(ordered_dict.values()[-2:], ['foo', 'bar']) def test_path_to_test_expectations_file(self): port = TestWebKitPort() @@ -562,7 +559,7 @@ class PortTestCase(unittest.TestCase): self.assertFalse(output.assert_outputs(self, port._build_driver, expected_stderr=expected_stderr, expected_logs=expected_logs)) def _assert_config_file_for_platform(self, port, platform, config_file): - self.assertEquals(port._apache_config_file_name_for_platform(platform), config_file) + self.assertEqual(port._apache_config_file_name_for_platform(platform), config_file) def test_linux_distro_detection(self): port = TestWebKitPort() @@ -604,19 +601,19 @@ class PortTestCase(unittest.TestCase): self.assertRaises(IOError, port._path_to_apache_config_file) port._filesystem.write_text_file('/existing/httpd.conf', 'Hello, world!') os.environ['WEBKIT_HTTP_SERVER_CONF_PATH'] = '/existing/httpd.conf' - self.assertEquals(port._path_to_apache_config_file(), '/existing/httpd.conf') + self.assertEqual(port._path_to_apache_config_file(), '/existing/httpd.conf') finally: os.environ = saved_environ.copy() # Mock out _apache_config_file_name_for_platform to ignore the passed sys.platform value. port._apache_config_file_name_for_platform = lambda platform: 'httpd.conf' - self.assertEquals(port._path_to_apache_config_file(), '/mock-checkout/LayoutTests/http/conf/httpd.conf') + self.assertEqual(port._path_to_apache_config_file(), '/mock-checkout/LayoutTests/http/conf/httpd.conf') # Check that even if we mock out _apache_config_file_name, the environment variable takes precedence. saved_environ = os.environ.copy() try: os.environ['WEBKIT_HTTP_SERVER_CONF_PATH'] = '/existing/httpd.conf' - self.assertEquals(port._path_to_apache_config_file(), '/existing/httpd.conf') + self.assertEqual(port._path_to_apache_config_file(), '/existing/httpd.conf') finally: os.environ = saved_environ.copy() @@ -646,4 +643,4 @@ class PortTestCase(unittest.TestCase): def test_additional_platform_directory(self): port = self.make_port(options=MockOptions(additional_platform_directory=['/tmp/foo'])) - self.assertEquals(port.baseline_search_path()[0], '/tmp/foo') + self.assertEqual(port.baseline_search_path()[0], '/tmp/foo') diff --git a/Tools/Scripts/webkitpy/layout_tests/port/qt_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/qt_unittest.py index cf09bd8e0..4a558f8dd 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/qt_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/qt_unittest.py @@ -69,7 +69,7 @@ class QtPortTest(port_testcase.PortTestCase): port = self.make_port(host=host, qt_version=qt_version, port_name=port_name, options=MockOptions(webkit_test_runner=use_webkit2, platform='qt')) absolute_search_paths = map(port._webkit_baseline_path, search_paths) - self.assertEquals(port.baseline_search_path(), absolute_search_paths) + self.assertEqual(port.baseline_search_path(), absolute_search_paths) def _assert_expectations_files(self, search_paths, os_name, use_webkit2=False, qt_version='4.8'): # FIXME: Port constructors should not "parse" the port name, but @@ -80,7 +80,7 @@ class QtPortTest(port_testcase.PortTestCase): port_name = 'qt-' + os_name port = self.make_port(host=host, qt_version=qt_version, port_name=port_name, options=MockOptions(webkit_test_runner=use_webkit2, platform='qt')) - self.assertEquals(port.expectations_files(), search_paths) + self.assertEqual(port.expectations_files(), search_paths) def _qt_version(self, qt_version): if qt_version in '4.8': @@ -110,7 +110,7 @@ class QtPortTest(port_testcase.PortTestCase): def test_setup_environ_for_server(self): port = self.make_port() env = port.setup_environ_for_server(port.driver_name()) - self.assertEquals(env['QTWEBKIT_PLUGIN_PATH'], '/mock-build/lib/plugins') + self.assertEqual(env['QTWEBKIT_PLUGIN_PATH'], '/mock-build/lib/plugins') def test_operating_system(self): self.assertEqual('linux', self.make_port(port_name='qt-linux', os_name='linux').operating_system()) diff --git a/Tools/Scripts/webkitpy/layout_tests/port/server_process_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/server_process_unittest.py index 7a5ac45d4..cd1db1f96 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/server_process_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/server_process_unittest.py @@ -104,23 +104,23 @@ class TestServerProcess(unittest.TestCase): proc = server_process.ServerProcess(port, 'python', cmd) proc.write('') - self.assertEquals(proc.poll(), None) + self.assertEqual(proc.poll(), None) self.assertFalse(proc.has_crashed()) # check that doing a read after an expired deadline returns # nothing immediately. line = proc.read_stdout_line(now - 1) - self.assertEquals(line, None) + self.assertEqual(line, None) # FIXME: This part appears to be flaky. line should always be non-None. # FIXME: https://bugs.webkit.org/show_bug.cgi?id=88280 line = proc.read_stdout_line(now + 1.0) if line: - self.assertEquals(line.strip(), "stdout") + self.assertEqual(line.strip(), "stdout") line = proc.read_stderr_line(now + 1.0) if line: - self.assertEquals(line.strip(), "stderr") + self.assertEqual(line.strip(), "stderr") proc.stop(0) @@ -141,12 +141,12 @@ class TestServerProcess(unittest.TestCase): server_process.write("should break") self.assertTrue(server_process.has_crashed()) self.assertNotEquals(server_process.pid(), None) - self.assertEquals(server_process._proc, None) - self.assertEquals(server_process.broken_pipes, [server_process.stdin]) + self.assertEqual(server_process._proc, None) + self.assertEqual(server_process.broken_pipes, [server_process.stdin]) port_obj.host.platform.os_name = 'mac' server_process = FakeServerProcess(port_obj=port_obj, name="test", cmd=["test"]) server_process.write("should break") self.assertTrue(server_process.has_crashed()) - self.assertEquals(server_process._proc, None) - self.assertEquals(server_process.broken_pipes, [server_process.stdin]) + self.assertEqual(server_process._proc, None) + self.assertEqual(server_process.broken_pipes, [server_process.stdin]) diff --git a/Tools/Scripts/webkitpy/layout_tests/port/win_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/win_unittest.py index 930dcd8e5..668685f56 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/win_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/win_unittest.py @@ -60,7 +60,7 @@ class WinPortTest(port_testcase.PortTestCase): def _assert_search_path(self, expected_search_paths, version, use_webkit2=False): port = self.make_port(port_name='win', os_version=version, options=MockOptions(webkit_test_runner=use_webkit2)) absolute_search_paths = map(port._webkit_baseline_path, expected_search_paths) - self.assertEquals(port.baseline_search_path(), absolute_search_paths) + self.assertEqual(port.baseline_search_path(), absolute_search_paths) def test_baseline_search_path(self): self._assert_search_path(['win-xp', 'win-vista', 'win-7sp0', 'win', 'mac-lion', 'mac'], 'xp') @@ -74,7 +74,7 @@ class WinPortTest(port_testcase.PortTestCase): def _assert_version(self, port_name, expected_version): host = MockSystemHost(os_name='win', os_version=expected_version) port = WinPort(host, port_name=port_name) - self.assertEquals(port.version(), expected_version) + self.assertEqual(port.version(), expected_version) def test_versions(self): self._assert_version('win-xp', 'xp') @@ -100,10 +100,10 @@ class WinPortTest(port_testcase.PortTestCase): port = self.make_port() port._executive.run_command = lambda command, cwd=None, error_handler=None: "Nonsense" # runtime_features_list returns None when its results are meaningless (it couldn't run DRT or parse the output, etc.) - self.assertEquals(port._runtime_feature_list(), None) + self.assertEqual(port._runtime_feature_list(), None) port._executive.run_command = lambda command, cwd=None, error_handler=None: "SupportedFeatures:foo bar" - self.assertEquals(port._runtime_feature_list(), ['foo', 'bar']) + self.assertEqual(port._runtime_feature_list(), ['foo', 'bar']) def test_expectations_files(self): - self.assertEquals(len(self.make_port().expectations_files()), 2) - self.assertEquals(len(self.make_port(options=MockOptions(webkit_test_runner=True)).expectations_files()), 4) + self.assertEqual(len(self.make_port().expectations_files()), 2) + self.assertEqual(len(self.make_port(options=MockOptions(webkit_test_runner=True, configuration='Release')).expectations_files()), 4) diff --git a/Tools/Scripts/webkitpy/layout_tests/port/xvfbdriver_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/xvfbdriver_unittest.py index 220dd3517..367131039 100644 --- a/Tools/Scripts/webkitpy/layout_tests/port/xvfbdriver_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/port/xvfbdriver_unittest.py @@ -34,14 +34,15 @@ from webkitpy.common.system.executive_mock import MockExecutive2 from webkitpy.common.system.outputcapture import OutputCapture from webkitpy.common.system.systemhost_mock import MockSystemHost from webkitpy.layout_tests.port import Port -from webkitpy.layout_tests.port.config_mock import MockConfig from webkitpy.layout_tests.port.server_process_mock import MockServerProcess from webkitpy.layout_tests.port.xvfbdriver import XvfbDriver +from webkitpy.tool.mocktool import MockOptions class XvfbDriverTest(unittest.TestCase): def make_driver(self, worker_number=0, xorg_running=False, executive=None): - port = Port(host=MockSystemHost(log_executive=True, executive=executive), config=MockConfig()) + port = Port(host=MockSystemHost(log_executive=True, executive=executive), options=MockOptions(configuration='Release')) + port._config.build_directory = lambda configuration: "/mock-build" port._server_process_constructor = MockServerProcess if xorg_running: port._executive._running_pids['Xorg'] = 108 @@ -115,7 +116,7 @@ class XvfbDriverTest(unittest.TestCase): def test_stop(self): filesystem = MockFileSystem(files={'/tmp/.X42-lock': '1234\n'}) - port = Port(host=MockSystemHost(log_executive=True, filesystem=filesystem), config=MockConfig()) + port = Port(host=MockSystemHost(log_executive=True, filesystem=filesystem), options=MockOptions(configuration='Release')) port._executive.kill_process = lambda x: log("MOCK kill_process pid: " + str(x)) driver = XvfbDriver(port, worker_number=0, pixel_tests=True) diff --git a/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py b/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py index 1c8e7321a..2df57cf6f 100755 --- a/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py +++ b/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py @@ -207,45 +207,9 @@ def parse_args(args=None): # FIXME: These options should move onto the ChromiumPort. option_group_definitions.append(("Chromium-specific Options", [ - optparse.make_option("--startup-dialog", action="store_true", - default=False, help="create a dialog on DumpRenderTree startup"), - optparse.make_option("--gp-fault-error-box", action="store_true", - default=False, help="enable Windows GP fault error box"), - optparse.make_option("--js-flags", - type="string", help="JavaScript flags to pass to tests"), - optparse.make_option("--stress-opt", action="store_true", - default=False, - help="Enable additional stress test to JavaScript optimization"), - optparse.make_option("--stress-deopt", action="store_true", - default=False, - help="Enable additional stress test to JavaScript optimization"), optparse.make_option("--nocheck-sys-deps", action="store_true", default=False, help="Don't check the system dependencies (themes)"), - optparse.make_option("--accelerated-video", - action="store_true", - help="Use hardware-accelerated compositing for video"), - optparse.make_option("--no-accelerated-video", - action="store_false", - dest="accelerated_video", - help="Don't use hardware-accelerated compositing for video"), - optparse.make_option("--threaded-compositing", - action="store_true", - help="Use threaded compositing for rendering"), - optparse.make_option("--accelerated-2d-canvas", - action="store_true", - help="Use hardware-accelerated 2D Canvas calls"), - optparse.make_option("--no-accelerated-2d-canvas", - action="store_false", - dest="accelerated_2d_canvas", - help="Don't use hardware-accelerated 2D Canvas calls"), - optparse.make_option("--accelerated-painting", - action="store_true", - default=False, - help="Use hardware accelerated painting of composited pages"), - optparse.make_option("--per-tile-painting", - action="store_true", - help="Use per-tile painting of composited pages"), optparse.make_option("--adb-device", action="append", default=[], help="Run Android layout tests on these devices."), diff --git a/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py b/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py index 0cf42d0ee..de1a21cc5 100755 --- a/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py +++ b/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py @@ -33,6 +33,7 @@ import codecs import itertools import json import logging +import os import platform import Queue import re @@ -241,12 +242,12 @@ class LintTest(unittest.TestCase, StreamTestingMixin): FakePort(host, 'b', 'path-to-b'), FakePort(host, 'b-win', 'path-to-b'))) - self.assertEquals(run_webkit_tests.lint(host.port_factory.ports['a'], MockOptions(platform=None)), 0) - self.assertEquals(host.ports_parsed, ['a', 'b', 'b-win']) + self.assertEqual(run_webkit_tests.lint(host.port_factory.ports['a'], MockOptions(platform=None)), 0) + self.assertEqual(host.ports_parsed, ['a', 'b', 'b-win']) host.ports_parsed = [] - self.assertEquals(run_webkit_tests.lint(host.port_factory.ports['a'], MockOptions(platform='a')), 0) - self.assertEquals(host.ports_parsed, ['a']) + self.assertEqual(run_webkit_tests.lint(host.port_factory.ports['a'], MockOptions(platform='a')), 0) + self.assertEqual(host.ports_parsed, ['a']) def test_lint_test_files(self): res, out, err, user = logging_run(['--lint-test-files']) @@ -286,19 +287,9 @@ class MainTest(unittest.TestCase, StreamTestingMixin): # properly on cygwin (bug 63846). self.should_test_processes = not self._platform.is_win() - def test_accelerated_compositing(self): - # This just tests that we recognize the command line args - self.assertTrue(passing_run(['--accelerated-video'])) - self.assertTrue(passing_run(['--no-accelerated-video'])) - - def test_accelerated_2d_canvas(self): - # This just tests that we recognize the command line args - self.assertTrue(passing_run(['--accelerated-2d-canvas'])) - self.assertTrue(passing_run(['--no-accelerated-2d-canvas'])) - def test_all(self): res, out, err, user = logging_run([], tests_included=True) - self.assertEquals(res, unexpected_tests_count) + self.assertEqual(res, unexpected_tests_count) def test_basic(self): self.assertTrue(passing_run()) @@ -309,10 +300,19 @@ class MainTest(unittest.TestCase, StreamTestingMixin): self.assertTrue(len(batch) <= 2, '%s had too many tests' % ', '.join(batch)) def test_max_locked_shards(self): + # Tests for the default of using one locked shard even in the case of more than one child process. if not self.should_test_processes: return + save_env_webkit_test_max_locked_shards = None + if "WEBKIT_TEST_MAX_LOCKED_SHARDS" in os.environ: + save_env_webkit_test_max_locked_shards = os.environ["WEBKIT_TEST_MAX_LOCKED_SHARDS"] + del os.environ["WEBKIT_TEST_MAX_LOCKED_SHARDS"] _, _, regular_output, _ = logging_run(['--debug-rwt-logging', '--child-processes', '2'], shared_port=False) - self.assertTrue(any(['(1 locked)' in line for line in regular_output.buflist])) + try: + self.assertTrue(any(['(1 locked)' in line for line in regular_output.buflist])) + finally: + if save_env_webkit_test_max_locked_shards: + os.environ["WEBKIT_TEST_MAX_LOCKED_SHARDS"] = save_env_webkit_test_max_locked_shards def test_child_processes_2(self): if self.should_test_processes: @@ -405,7 +405,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): def test_repeat_each(self): tests_to_run = ['passes/image.html', 'passes/text.html'] tests_run = get_tests_run(['--repeat-each', '2'] + tests_to_run, tests_included=True, flatten_batches=True) - self.assertEquals(tests_run, ['passes/image.html', 'passes/image.html', 'passes/text.html', 'passes/text.html']) + self.assertEqual(tests_run, ['passes/image.html', 'passes/image.html', 'passes/text.html', 'passes/text.html']) def test_ignore_flag(self): # Note that passes/image.html is expected to be run since we specified it directly. @@ -419,26 +419,26 @@ class MainTest(unittest.TestCase, StreamTestingMixin): num_tests_run_by_default = len(tests_run) # Check that nothing changes when we specify skipped=default. - self.assertEquals(len(get_tests_run(['--skipped=default', 'passes'], tests_included=True, flatten_batches=True)), + self.assertEqual(len(get_tests_run(['--skipped=default', 'passes'], tests_included=True, flatten_batches=True)), num_tests_run_by_default) # Now check that we run one more test (the skipped one). tests_run = get_tests_run(['--skipped=ignore', 'passes'], tests_included=True, flatten_batches=True) self.assertTrue('passes/skipped/skip.html' in tests_run) - self.assertEquals(len(tests_run), num_tests_run_by_default + 1) + self.assertEqual(len(tests_run), num_tests_run_by_default + 1) # Now check that we only run the skipped test. - self.assertEquals(get_tests_run(['--skipped=only', 'passes'], tests_included=True, flatten_batches=True), + self.assertEqual(get_tests_run(['--skipped=only', 'passes'], tests_included=True, flatten_batches=True), ['passes/skipped/skip.html']) # Now check that we don't run anything. - self.assertEquals(get_tests_run(['--skipped=always', 'passes/skipped/skip.html'], tests_included=True, flatten_batches=True), + self.assertEqual(get_tests_run(['--skipped=always', 'passes/skipped/skip.html'], tests_included=True, flatten_batches=True), []) def test_iterations(self): tests_to_run = ['passes/image.html', 'passes/text.html'] tests_run = get_tests_run(['--iterations', '2'] + tests_to_run, tests_included=True, flatten_batches=True) - self.assertEquals(tests_run, ['passes/image.html', 'passes/text.html', 'passes/image.html', 'passes/text.html']) + self.assertEqual(tests_run, ['passes/image.html', 'passes/text.html', 'passes/image.html', 'passes/text.html']) def test_repeat_each_iterations_num_tests(self): # The total number of tests should be: number_of_tests * @@ -456,12 +456,12 @@ class MainTest(unittest.TestCase, StreamTestingMixin): # Test that we actually select the right chunk all_tests_run = get_tests_run(flatten_batches=True) chunk_tests_run = get_tests_run(['--run-chunk', '1:4'], flatten_batches=True) - self.assertEquals(all_tests_run[4:8], chunk_tests_run) + self.assertEqual(all_tests_run[4:8], chunk_tests_run) # Test that we wrap around if the number of tests is not evenly divisible by the chunk size tests_to_run = ['passes/error.html', 'passes/image.html', 'passes/platform_image.html', 'passes/text.html'] chunk_tests_run = get_tests_run(['--run-chunk', '1:3'] + tests_to_run, tests_included=True, flatten_batches=True) - self.assertEquals(['passes/text.html', 'passes/error.html', 'passes/image.html'], chunk_tests_run) + self.assertEqual(['passes/text.html', 'passes/error.html', 'passes/image.html'], chunk_tests_run) def test_run_force(self): # This raises an exception because we run @@ -474,18 +474,18 @@ class MainTest(unittest.TestCase, StreamTestingMixin): # Test that we actually select the right part tests_to_run = ['passes/error.html', 'passes/image.html', 'passes/platform_image.html', 'passes/text.html'] tests_run = get_tests_run(['--run-part', '1:2'] + tests_to_run, tests_included=True, flatten_batches=True) - self.assertEquals(['passes/error.html', 'passes/image.html'], tests_run) + self.assertEqual(['passes/error.html', 'passes/image.html'], tests_run) # Test that we wrap around if the number of tests is not evenly divisible by the chunk size # (here we end up with 3 parts, each with 2 tests, and we only have 4 tests total, so the # last part repeats the first two tests). chunk_tests_run = get_tests_run(['--run-part', '3:3'] + tests_to_run, tests_included=True, flatten_batches=True) - self.assertEquals(['passes/error.html', 'passes/image.html'], chunk_tests_run) + self.assertEqual(['passes/error.html', 'passes/image.html'], chunk_tests_run) def test_run_singly(self): batch_tests_run = get_tests_run(['--run-singly']) for batch in batch_tests_run: - self.assertEquals(len(batch), 1, '%s had too many tests' % ', '.join(batch)) + self.assertEqual(len(batch), 1, '%s had too many tests' % ', '.join(batch)) def test_skip_failing_tests(self): # This tests that we skip both known failing and known flaky tests. Because there are @@ -503,28 +503,28 @@ class MainTest(unittest.TestCase, StreamTestingMixin): def test_run_singly_actually_runs_tests(self): res, _, _, _ = logging_run(['--run-singly', 'failures/unexpected']) - self.assertEquals(res, unexpected_failures) + self.assertEqual(res, unexpected_failures) def test_single_file(self): # FIXME: We should consider replacing more of the get_tests_run()-style tests # with tests that read the tests_run* files, like this one. host = MockHost() tests_run = passing_run(['passes/text.html'], tests_included=True, host=host) - self.assertEquals(host.filesystem.read_text_file('/tmp/layout-test-results/tests_run0.txt'), + self.assertEqual(host.filesystem.read_text_file('/tmp/layout-test-results/tests_run0.txt'), 'passes/text.html\n') def test_single_file_with_prefix(self): tests_run = get_tests_run(['LayoutTests/passes/text.html'], tests_included=True, flatten_batches=True) - self.assertEquals(['passes/text.html'], tests_run) + self.assertEqual(['passes/text.html'], tests_run) def test_single_skipped_file(self): tests_run = get_tests_run(['failures/expected/keybaord.html'], tests_included=True, flatten_batches=True) - self.assertEquals([], tests_run) + self.assertEqual([], tests_run) def test_stderr_is_saved(self): host = MockHost() self.assertTrue(passing_run(host=host)) - self.assertEquals(host.filesystem.read_text_file('/tmp/layout-test-results/passes/error-stderr.txt'), + self.assertEqual(host.filesystem.read_text_file('/tmp/layout-test-results/passes/error-stderr.txt'), 'stuff going to stderr') def test_test_list(self): @@ -532,7 +532,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): filename = '/tmp/foo.txt' host.filesystem.write_text_file(filename, 'passes/text.html') tests_run = get_tests_run(['--test-list=%s' % filename], tests_included=True, flatten_batches=True, host=host) - self.assertEquals(['passes/text.html'], tests_run) + self.assertEqual(['passes/text.html'], tests_run) host.filesystem.remove(filename) res, out, err, user = logging_run(['--test-list=%s' % filename], tests_included=True, host=host) @@ -544,7 +544,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): filename = '/tmp/foo.txt' host.filesystem.write_text_file(filename, 'LayoutTests/passes/text.html') tests_run = get_tests_run(['--test-list=%s' % filename], tests_included=True, flatten_batches=True, host=host) - self.assertEquals(['passes/text.html'], tests_run) + self.assertEqual(['passes/text.html'], tests_run) def test_unexpected_failures(self): # Run tests including the unexpected failures. @@ -567,7 +567,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): tests_included=True, host=host, record_results=True) file_list = host.filesystem.written_files.keys() file_list.remove('/tmp/layout-test-results/tests_run0.txt') - self.assertEquals(res, 1) + self.assertEqual(res, 1) expected_token = '"unexpected":{"text-image-checksum.html":{"expected":"PASS","actual":"IMAGE+TEXT","image_diff_percent":1},"missing_text.html":{"expected":"PASS","is_missing_text":true,"actual":"MISSING"}' json_string = host.filesystem.read_text_file('/tmp/layout-test-results/full_results.json') self.assertTrue(json_string.find(expected_token) != -1) @@ -584,7 +584,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): 'failures/unexpected/image_not_in_pixeldir.html'] res, out, err, _ = logging_run(extra_args=args, host=host, record_results=True, tests_included=True) - self.assertEquals(res, 1) + self.assertEqual(res, 1) expected_token = '"unexpected":{"pixeldir":{"image_in_pixeldir.html":{"expected":"PASS","actual":"IMAGE"' json_string = host.filesystem.read_text_file('/tmp/layout-test-results/full_results.json') self.assertTrue(json_string.find(expected_token) != -1) @@ -604,7 +604,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): 'failures/unexpected/missing_text.html', 'failures/unexpected/text-image-checksum.html'], tests_included=True, host=host, record_results=True, port_obj=test_port) - self.assertEquals(res, 2) + self.assertEqual(res, 2) def test_crash_with_stderr(self): host = MockHost() @@ -641,7 +641,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): record_results=True, host=host) expected_crash_log = mock_crash_report - self.assertEquals(host.filesystem.read_text_file('/tmp/layout-test-results/failures/unexpected/crash-with-stderr-crash-log.txt'), expected_crash_log) + self.assertEqual(host.filesystem.read_text_file('/tmp/layout-test-results/failures/unexpected/crash-with-stderr-crash-log.txt'), expected_crash_log) def test_web_process_crash_log(self): # FIXME: Need to rewrite these tests to not be mac-specific, or move them elsewhere. @@ -657,7 +657,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): tests_included=True, record_results=True, host=host) - self.assertEquals(host.filesystem.read_text_file('/tmp/layout-test-results/failures/unexpected/web-process-crash-with-stderr-crash-log.txt'), mock_crash_report) + self.assertEqual(host.filesystem.read_text_file('/tmp/layout-test-results/failures/unexpected/web-process-crash-with-stderr-crash-log.txt'), mock_crash_report) def test_exit_after_n_failures_upload(self): host = MockHost() @@ -674,7 +674,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): self.assertFalse(host.filesystem.exists('/tmp/layout-test-results/incremental_results.json')) # This checks that we report only the number of tests that actually failed. - self.assertEquals(res, 1) + self.assertEqual(res, 1) # This checks that passes/text.html is considered SKIPped. self.assertTrue('"skipped":1' in host.filesystem.read_text_file('/tmp/layout-test-results/full_results.json')) @@ -695,7 +695,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): ], tests_included=True, flatten_batches=True) - self.assertEquals(['failures/unexpected/text-image-checksum.html'], tests_run) + self.assertEqual(['failures/unexpected/text-image-checksum.html'], tests_run) # But we'll keep going for expected ones. tests_run = get_tests_run([ @@ -705,7 +705,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): ], tests_included=True, flatten_batches=True) - self.assertEquals(['failures/expected/text.html', 'passes/text.html'], tests_run) + self.assertEqual(['failures/expected/text.html', 'passes/text.html'], tests_run) def test_exit_after_n_crashes(self): # Unexpected crashes should result in tests stopping. @@ -716,7 +716,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): ], tests_included=True, flatten_batches=True) - self.assertEquals(['failures/unexpected/crash.html'], tests_run) + self.assertEqual(['failures/unexpected/crash.html'], tests_run) # Same with timeouts. tests_run = get_tests_run([ @@ -726,7 +726,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): ], tests_included=True, flatten_batches=True) - self.assertEquals(['failures/unexpected/timeout.html'], tests_run) + self.assertEqual(['failures/unexpected/timeout.html'], tests_run) # But we'll keep going for expected ones. tests_run = get_tests_run([ @@ -736,7 +736,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): ], tests_included=True, flatten_batches=True) - self.assertEquals(['failures/expected/crash.html', 'passes/text.html'], tests_run) + self.assertEqual(['failures/expected/crash.html', 'passes/text.html'], tests_run) def test_results_directory_absolute(self): # We run a configuration that should fail, to generate output, then @@ -769,7 +769,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): def test_retrying_and_flaky_tests(self): host = MockHost() res, out, err, _ = logging_run(['--debug-rwt-logging', 'failures/flaky'], tests_included=True, host=host) - self.assertEquals(res, 0) + self.assertEqual(res, 0) self.assertTrue('Retrying' in err.getvalue()) self.assertTrue('Unexpected flakiness' in out.getvalue()) self.assertTrue(host.filesystem.exists('/tmp/layout-test-results/failures/flaky/text-actual.txt')) @@ -780,7 +780,7 @@ class MainTest(unittest.TestCase, StreamTestingMixin): # and that we don't retry again. host = MockHost() res, out, err, _ = logging_run(['--no-retry-failures', '--clobber-old-results', 'failures/flaky'], tests_included=True, host=host) - self.assertEquals(res, 1) + self.assertEqual(res, 1) self.assertTrue('Clobbering old results' in err.getvalue()) self.assertTrue('flaky/text.html' in err.getvalue()) self.assertTrue('Unexpected text-only failures' in out.getvalue()) @@ -793,10 +793,10 @@ class MainTest(unittest.TestCase, StreamTestingMixin): # order per directory. HTTP tests are sharded separately from other tests, # so we have to test both. tests_run = get_tests_run(['-i', 'passes/passes', 'passes'], tests_included=True, flatten_batches=True) - self.assertEquals(tests_run, sorted(tests_run)) + self.assertEqual(tests_run, sorted(tests_run)) tests_run = get_tests_run(['http/tests/passes'], tests_included=True, flatten_batches=True) - self.assertEquals(tests_run, sorted(tests_run)) + self.assertEqual(tests_run, sorted(tests_run)) def test_tolerance(self): class ImageDiffTestPort(TestPort): @@ -831,29 +831,29 @@ class MainTest(unittest.TestCase, StreamTestingMixin): def test_reftest_run(self): tests_run = get_tests_run(['passes/reftest.html'], tests_included=True, flatten_batches=True) - self.assertEquals(['passes/reftest.html'], tests_run) + self.assertEqual(['passes/reftest.html'], tests_run) def test_reftest_run_reftests_if_pixel_tests_are_disabled(self): tests_run = get_tests_run(['--no-pixel-tests', 'passes/reftest.html'], tests_included=True, flatten_batches=True) - self.assertEquals(['passes/reftest.html'], tests_run) + self.assertEqual(['passes/reftest.html'], tests_run) def test_reftest_skip_reftests_if_no_ref_tests(self): tests_run = get_tests_run(['--no-ref-tests', 'passes/reftest.html'], tests_included=True, flatten_batches=True) - self.assertEquals([], tests_run) + self.assertEqual([], tests_run) tests_run = get_tests_run(['--no-ref-tests', '--no-pixel-tests', 'passes/reftest.html'], tests_included=True, flatten_batches=True) - self.assertEquals([], tests_run) + self.assertEqual([], tests_run) def test_reftest_expected_html_should_be_ignored(self): tests_run = get_tests_run(['passes/reftest-expected.html'], tests_included=True, flatten_batches=True) - self.assertEquals([], tests_run) + self.assertEqual([], tests_run) def test_reftest_driver_should_run_expected_html(self): tests_run = get_tests_run(['passes/reftest.html'], tests_included=True, flatten_batches=True, include_reference_html=True) - self.assertEquals(['passes/reftest.html', 'passes/reftest-expected.html'], tests_run) + self.assertEqual(['passes/reftest.html', 'passes/reftest-expected.html'], tests_run) def test_reftest_driver_should_run_expected_mismatch_html(self): tests_run = get_tests_run(['passes/mismatch.html'], tests_included=True, flatten_batches=True, include_reference_html=True) - self.assertEquals(['passes/mismatch.html', 'passes/mismatch-expected-mismatch.html'], tests_run) + self.assertEqual(['passes/mismatch.html', 'passes/mismatch-expected-mismatch.html'], tests_run) def test_reftest_should_not_use_naming_convention_if_not_listed_in_reftestlist(self): host = MockHost() @@ -916,8 +916,8 @@ class MainTest(unittest.TestCase, StreamTestingMixin): full_results_text = host.filesystem.read_text_file('/tmp/layout-test-results/full_results.json') full_results = json.loads(full_results_text.replace("ADD_RESULTS(", "").replace(");", "")) - self.assertEquals(full_results['has_wdiff'], False) - self.assertEquals(full_results['has_pretty_patch'], False) + self.assertEqual(full_results['has_wdiff'], False) + self.assertEqual(full_results['has_pretty_patch'], False) def test_unsupported_platform(self): oc = outputcapture.OutputCapture() @@ -927,12 +927,12 @@ class MainTest(unittest.TestCase, StreamTestingMixin): finally: stdout, stderr, logs = oc.restore_output() - self.assertEquals(res, run_webkit_tests.EXCEPTIONAL_EXIT_STATUS) - self.assertEquals(stdout, '') + self.assertEqual(res, run_webkit_tests.EXCEPTIONAL_EXIT_STATUS) + self.assertEqual(stdout, '') self.assertTrue('unsupported platform' in stderr) # This is empty because we don't even get a chance to configure the logger before failing. - self.assertEquals(logs, '') + self.assertEqual(logs, '') def test_verbose_in_child_processes(self): # When we actually run multiple processes, we may have to reconfigure logging in the @@ -964,11 +964,11 @@ class EndToEndTest(unittest.TestCase): host = MockHost() res, out, err, user = logging_run(record_results=True, tests_included=True, host=host) - self.assertEquals(res, unexpected_tests_count) + self.assertEqual(res, unexpected_tests_count) results = self.parse_full_results(host.filesystem.read_text_file('/tmp/layout-test-results/full_results.json')) # Check to ensure we're passing back image diff %age correctly. - self.assertEquals(results['tests']['failures']['expected']['image.html']['image_diff_percent'], 1) + self.assertEqual(results['tests']['failures']['expected']['image.html']['image_diff_percent'], 1) # Check that we attempted to display the results page in a browser. self.assertTrue(user.opened_urls) @@ -1016,7 +1016,7 @@ class RebaselineTest(unittest.TestCase, StreamTestingMixin): tests_included=True, host=host, new_results=True) file_list = host.filesystem.written_files.keys() file_list.remove('/tmp/layout-test-results/tests_run0.txt') - self.assertEquals(res, 0) + self.assertEqual(res, 0) self.assertEmpty(out) self.assertEqual(len(file_list), 4) self.assertBaselines(file_list, "passes/image", [".txt", ".png"], err) @@ -1034,7 +1034,7 @@ class RebaselineTest(unittest.TestCase, StreamTestingMixin): tests_included=True, host=host, new_results=True) file_list = host.filesystem.written_files.keys() file_list.remove('/tmp/layout-test-results/tests_run0.txt') - self.assertEquals(res, 0) + self.assertEqual(res, 0) self.assertNotEmpty(out) self.assertEqual(len(file_list), 6) self.assertBaselines(file_list, "failures/unexpected/missing_text", [".txt"], err) @@ -1052,7 +1052,7 @@ class RebaselineTest(unittest.TestCase, StreamTestingMixin): tests_included=True, host=host, new_results=True) file_list = host.filesystem.written_files.keys() file_list.remove('/tmp/layout-test-results/tests_run0.txt') - self.assertEquals(res, 0) + self.assertEqual(res, 0) self.assertEmpty(out) self.assertEqual(len(file_list), 4) self.assertBaselines(file_list, diff --git a/Tools/Scripts/webkitpy/layout_tests/servers/http_server_base.py b/Tools/Scripts/webkitpy/layout_tests/servers/http_server_base.py index c1c3da827..6a0ce58b0 100755 --- a/Tools/Scripts/webkitpy/layout_tests/servers/http_server_base.py +++ b/Tools/Scripts/webkitpy/layout_tests/servers/http_server_base.py @@ -194,7 +194,7 @@ class HttpServerBase(object): except IOError, e: if e.errno in (errno.EALREADY, errno.EADDRINUSE): raise ServerError('Port %d is already in use.' % port) - elif sys.platform == 'win32' and e.errno in (errno.WSAEACCES,): + elif sys.platform == 'win32' and e.errno in (errno.WSAEACCES,): # pylint: disable-msg=E1101 raise ServerError('Port %d is already in use.' % port) else: raise diff --git a/Tools/Scripts/webkitpy/layout_tests/servers/http_server_integrationtest.py b/Tools/Scripts/webkitpy/layout_tests/servers/http_server_integrationtest.py index 237d689ce..37faa6429 100755 --- a/Tools/Scripts/webkitpy/layout_tests/servers/http_server_integrationtest.py +++ b/Tools/Scripts/webkitpy/layout_tests/servers/http_server_integrationtest.py @@ -80,9 +80,9 @@ class BaseTest(unittest.TestCase): return self.assert_servers_are_down() - self.assertEquals(self.run_script(['--server', 'start']), 0) + self.assertEqual(self.run_script(['--server', 'start']), 0) self.assert_servers_are_up() - self.assertEquals(self.run_script(['--server', 'stop']), 0) + self.assertEqual(self.run_script(['--server', 'stop']), 0) self.assert_servers_are_down() def integration_test_server__fails(self): @@ -99,13 +99,13 @@ class BaseTest(unittest.TestCase): if e.errno in (errno.EADDRINUSE, errno.EALREADY): self.fail('could not bind to port %d: %s' % (port_number, str(e))) raise - self.assertEquals(self.run_script(['--server', 'start']), 1) + self.assertEqual(self.run_script(['--server', 'start']), 1) finally: self.run_script(['--server', 'stop']) test_socket.close() # Test that calling stop() twice is harmless. - self.assertEquals(self.run_script(['--server', 'stop']), 0) + self.assertEqual(self.run_script(['--server', 'stop']), 0) def maybe_make_dir(self, *comps): try: @@ -124,9 +124,9 @@ class BaseTest(unittest.TestCase): self.maybe_make_dir(tmpdir, 'media') self.assert_servers_are_down([18000]) - self.assertEquals(self.run_script(['--server', 'start', '--port=18000', '--root', tmpdir]), 0) + self.assertEqual(self.run_script(['--server', 'start', '--port=18000', '--root', tmpdir]), 0) self.assert_servers_are_up([18000]) - self.assertEquals(self.run_script(['--server', 'stop']), 0) + self.assertEqual(self.run_script(['--server', 'stop']), 0) self.assert_servers_are_down([18000]) diff --git a/Tools/Scripts/webkitpy/layout_tests/servers/http_server_unittest.py b/Tools/Scripts/webkitpy/layout_tests/servers/http_server_unittest.py index 7a14526d1..5cc4a6ee0 100644 --- a/Tools/Scripts/webkitpy/layout_tests/servers/http_server_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/servers/http_server_unittest.py @@ -56,7 +56,7 @@ class TestHttpServer(unittest.TestCase): self.assertRaises(ServerError, server.start) config_file = host.filesystem.read_text_file("/mock/output_dir/lighttpd.conf") - self.assertEquals(re.findall(r"alias.url.+", config_file), [ + self.assertEqual(re.findall(r"alias.url.+", config_file), [ 'alias.url = ( "/js-test-resources" => "/test.checkout/LayoutTests/fast/js/resources" )', 'alias.url += ( "/mock/one-additional-dir" => "/mock-checkout/one-additional-dir" )', 'alias.url += ( "/mock/another-additional-dir" => "/mock-checkout/one-additional-dir" )', diff --git a/Tools/Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py b/Tools/Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py index b388ec608..6620cbb04 100644 --- a/Tools/Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py @@ -76,7 +76,7 @@ class RegularTest(unittest.TestCase): self.meter.write_throttled_update('foo') self.meter.write_update('bar') self.meter.write('baz') - self.assertEquals(logging_stream.buflist, []) + self.assertEqual(logging_stream.buflist, []) finally: root_logger.removeHandler(handler) root_logger.setLevel(orig_level) @@ -88,12 +88,12 @@ class RegularTest(unittest.TestCase): self.meter.write_throttled_update('baz') self.meter.write_throttled_update('baz 2') self.meter.writeln('done') - self.assertEquals(self.times, []) + self.assertEqual(self.times, []) return self.buflist def test_basic(self): buflist = self._basic([0, 1, 2, 13, 14]) - self.assertEquals(buflist, ['foo\n', 'bar\n', 'baz 2\n', 'done\n']) + self.assertEqual(buflist, ['foo\n', 'bar\n', 'baz 2\n', 'done\n']) def _log_after_update(self): self.meter.write_update('foo') @@ -102,11 +102,11 @@ class RegularTest(unittest.TestCase): def test_log_after_update(self): buflist = self._log_after_update() - self.assertEquals(buflist, ['foo\n', 'bar\n']) + self.assertEqual(buflist, ['foo\n', 'bar\n']) def test_log_args(self): self.logger.info('foo %s %d', 'bar', 2) - self.assertEquals(self.buflist, ['foo bar 2\n']) + self.assertEqual(self.buflist, ['foo bar 2\n']) class TtyTest(RegularTest): verbose = False @@ -114,14 +114,14 @@ class TtyTest(RegularTest): def test_basic(self): buflist = self._basic([0, 1, 1.05, 1.1, 2]) - self.assertEquals(buflist, ['foo', + self.assertEqual(buflist, ['foo', MeteredStream._erasure('foo'), 'bar', MeteredStream._erasure('bar'), 'baz 2', MeteredStream._erasure('baz 2'), 'done\n']) def test_log_after_update(self): buflist = self._log_after_update() - self.assertEquals(buflist, ['foo', + self.assertEqual(buflist, ['foo', MeteredStream._erasure('foo'), 'bar\n']) @@ -137,7 +137,7 @@ class VerboseTest(RegularTest): self.assertTrue(re.match('\d\d:\d\d:01.000 8675 bar\n', buflist[1])) self.assertTrue(re.match('\d\d:\d\d:13.000 8675 baz 2\n', buflist[2])) self.assertTrue(re.match('\d\d:\d\d:14.123 8675 done\n', buflist[3])) - self.assertEquals(len(buflist), 4) + self.assertEqual(len(buflist), 4) def test_log_after_update(self): buflist = self._log_after_update() @@ -146,11 +146,11 @@ class VerboseTest(RegularTest): # The second argument should have a real timestamp and pid, so we just check the format. self.assertTrue(re.match('\d\d:\d\d:\d\d.\d\d\d \d+ bar\n', buflist[1])) - self.assertEquals(len(buflist), 2) + self.assertEqual(len(buflist), 2) def test_log_args(self): self.logger.info('foo %s %d', 'bar', 2) - self.assertEquals(len(self.buflist), 1) + self.assertEqual(len(self.buflist), 1) self.assertTrue(self.buflist[0].endswith('foo bar 2\n')) diff --git a/Tools/Scripts/webkitpy/layout_tests/views/printing_unittest.py b/Tools/Scripts/webkitpy/layout_tests/views/printing_unittest.py index bc30092f4..c0b928b0c 100644 --- a/Tools/Scripts/webkitpy/layout_tests/views/printing_unittest.py +++ b/Tools/Scripts/webkitpy/layout_tests/views/printing_unittest.py @@ -67,7 +67,7 @@ class Testprinter(unittest.TestCase): self.assertTrue(stream.getvalue()) def assertWritten(self, stream, contents): - self.assertEquals(stream.buflist, contents) + self.assertEqual(stream.buflist, contents) def reset(self, stream): stream.buflist = [] @@ -259,27 +259,27 @@ BUGX : failures/expected/timeout.html = TIMEOUT printer, _, _ = self.get_printer() printer._meter.number_of_columns = lambda: 80 actual = printer._test_status_line('fast/dom/HTMLFormElement/associated-elements-after-index-assertion-fail1.html', ' passed') - self.assertEquals(80, len(actual)) - self.assertEquals(actual, '[0/0] fast/dom/HTMLFormElement/associa...after-index-assertion-fail1.html passed') + self.assertEqual(80, len(actual)) + self.assertEqual(actual, '[0/0] fast/dom/HTMLFormElement/associa...after-index-assertion-fail1.html passed') printer._meter.number_of_columns = lambda: 89 actual = printer._test_status_line('fast/dom/HTMLFormElement/associated-elements-after-index-assertion-fail1.html', ' passed') - self.assertEquals(89, len(actual)) - self.assertEquals(actual, '[0/0] fast/dom/HTMLFormElement/associated-...ents-after-index-assertion-fail1.html passed') + self.assertEqual(89, len(actual)) + self.assertEqual(actual, '[0/0] fast/dom/HTMLFormElement/associated-...ents-after-index-assertion-fail1.html passed') printer._meter.number_of_columns = lambda: sys.maxint actual = printer._test_status_line('fast/dom/HTMLFormElement/associated-elements-after-index-assertion-fail1.html', ' passed') - self.assertEquals(90, len(actual)) - self.assertEquals(actual, '[0/0] fast/dom/HTMLFormElement/associated-elements-after-index-assertion-fail1.html passed') + self.assertEqual(90, len(actual)) + self.assertEqual(actual, '[0/0] fast/dom/HTMLFormElement/associated-elements-after-index-assertion-fail1.html passed') printer._meter.number_of_columns = lambda: 18 actual = printer._test_status_line('fast/dom/HTMLFormElement/associated-elements-after-index-assertion-fail1.html', ' passed') - self.assertEquals(18, len(actual)) - self.assertEquals(actual, '[0/0] f...l passed') + self.assertEqual(18, len(actual)) + self.assertEqual(actual, '[0/0] f...l passed') printer._meter.number_of_columns = lambda: 10 actual = printer._test_status_line('fast/dom/HTMLFormElement/associated-elements-after-index-assertion-fail1.html', ' passed') - self.assertEquals(actual, '[0/0] associated-elements-after-index-assertion-fail1.html passed') + self.assertEqual(actual, '[0/0] associated-elements-after-index-assertion-fail1.html passed') def test_details(self): printer, err, _ = self.get_printer(['--details']) diff --git a/Tools/Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py b/Tools/Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py index 9c9295f63..62e7353df 100755 --- a/Tools/Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py +++ b/Tools/Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py @@ -47,7 +47,7 @@ from webkitpy.performance_tests.perftestsrunner import PerfTestsRunner class MainTest(unittest.TestCase): def assertWritten(self, stream, contents): - self.assertEquals(stream.buflist, contents) + self.assertEqual(stream.buflist, contents) def normalizeFinishedTime(self, log): return re.sub(r'Finished: [0-9\.]+ s', 'Finished: 0.1 s', log) diff --git a/Tools/Scripts/webkitpy/style/checker.py b/Tools/Scripts/webkitpy/style/checker.py index 9f27c36da..282c33b70 100644 --- a/Tools/Scripts/webkitpy/style/checker.py +++ b/Tools/Scripts/webkitpy/style/checker.py @@ -106,6 +106,9 @@ _BASE_FILTER_RULES = [ # with the 79 character limit, or some higher limit that is # agreeable to the WebKit project. '-pep8/E501', + + # FIXME: Move the pylint rules from the pylintrc to here. This will + # also require us to re-work lint-webkitpy to produce the equivalent output. ] diff --git a/Tools/Scripts/webkitpy/style/checker_unittest.py b/Tools/Scripts/webkitpy/style/checker_unittest.py index d834fd557..3de39ebb0 100755 --- a/Tools/Scripts/webkitpy/style/checker_unittest.py +++ b/Tools/Scripts/webkitpy/style/checker_unittest.py @@ -169,7 +169,7 @@ class GlobalVariablesTest(unittest.TestCase): # Also do some additional checks. for rule in base_filter_rules: # Check no leading or trailing white space. - self.assertEquals(rule, rule.strip()) + self.assertEqual(rule, rule.strip()) # All categories are on by default, so defaults should # begin with -. self.assertTrue(rule.startswith('-')) @@ -335,8 +335,8 @@ class CheckerDispatcherSkipTest(unittest.TestCase): handle_style_error=None, min_confidence=3) message = 'while checking: %s' % path - self.assertEquals(checker is None, is_checker_none, message) - self.assertEquals(self._dispatcher.should_skip_without_warning(path), + self.assertEqual(checker is None, is_checker_none, message) + self.assertEqual(self._dispatcher.should_skip_without_warning(path), expected, message) def test_should_skip_without_warning__true(self): @@ -378,7 +378,7 @@ class CheckerDispatcherCarriageReturnTest(unittest.TestCase): dispatcher = CheckerDispatcher() for file_path, expected_result in files.items(): - self.assertEquals(dispatcher.should_check_and_strip_carriage_returns(file_path), expected_result, 'Checking: %s' % file_path) + self.assertEqual(dispatcher.should_check_and_strip_carriage_returns(file_path), expected_result, 'Checking: %s' % file_path) class CheckerDispatcherDispatchTest(unittest.TestCase): @@ -403,7 +403,7 @@ class CheckerDispatcherDispatchTest(unittest.TestCase): """Assert the type of the dispatched checker.""" checker = self.dispatch(file_path) got_class = checker.__class__ - self.assertEquals(got_class, expected_class, + self.assertEqual(got_class, expected_class, 'For path "%(file_path)s" got %(got_class)s when ' "expecting %(expected_class)s." % {"file_path": file_path, @@ -449,8 +449,8 @@ class CheckerDispatcherDispatchTest(unittest.TestCase): file_path = "ChangeLog" self.assert_checker_changelog(file_path) checker = self.dispatch(file_path) - self.assertEquals(checker.file_path, file_path) - self.assertEquals(checker.handle_style_error, + self.assertEqual(checker.file_path, file_path) + self.assertEqual(checker.handle_style_error, self.mock_handle_style_error) def test_cpp_paths(self): @@ -471,18 +471,18 @@ class CheckerDispatcherDispatchTest(unittest.TestCase): file_path = file_base + "." + file_extension self.assert_checker_cpp(file_path) checker = self.dispatch(file_path) - self.assertEquals(checker.file_extension, file_extension) - self.assertEquals(checker.file_path, file_path) - self.assertEquals(checker.handle_style_error, self.mock_handle_style_error) - self.assertEquals(checker.min_confidence, 3) + self.assertEqual(checker.file_extension, file_extension) + self.assertEqual(checker.file_path, file_path) + self.assertEqual(checker.handle_style_error, self.mock_handle_style_error) + self.assertEqual(checker.min_confidence, 3) # Check "-" for good measure. file_base = "-" file_extension = "" file_path = file_base self.assert_checker_cpp(file_path) checker = self.dispatch(file_path) - self.assertEquals(checker.file_extension, file_extension) - self.assertEquals(checker.file_path, file_path) + self.assertEqual(checker.file_extension, file_extension) + self.assertEqual(checker.file_path, file_path) def test_json_paths(self): """Test paths that should be checked as JSON.""" @@ -500,7 +500,7 @@ class CheckerDispatcherDispatchTest(unittest.TestCase): file_path = file_base + "." + file_extension self.assert_checker_json(file_path) checker = self.dispatch(file_path) - self.assertEquals(checker._handle_style_error, + self.assertEqual(checker._handle_style_error, self.mock_handle_style_error) def test_python_paths(self): @@ -519,8 +519,8 @@ class CheckerDispatcherDispatchTest(unittest.TestCase): file_path = file_base + "." + file_extension self.assert_checker_text(file_path) checker = self.dispatch(file_path) - self.assertEquals(checker.file_path, file_path) - self.assertEquals(checker.handle_style_error, + self.assertEqual(checker.file_path, file_path) + self.assertEqual(checker.handle_style_error, self.mock_handle_style_error) def test_text_paths(self): @@ -563,8 +563,8 @@ class CheckerDispatcherDispatchTest(unittest.TestCase): file_path = file_base + "." + file_extension self.assert_checker_text(file_path) checker = self.dispatch(file_path) - self.assertEquals(checker.file_path, file_path) - self.assertEquals(checker.handle_style_error, self.mock_handle_style_error) + self.assertEqual(checker.file_path, file_path) + self.assertEqual(checker.handle_style_error, self.mock_handle_style_error) def test_xml_paths(self): """Test paths that should be checked as XML.""" @@ -582,7 +582,7 @@ class CheckerDispatcherDispatchTest(unittest.TestCase): file_path = file_base + "." + file_extension self.assert_checker_xml(file_path) checker = self.dispatch(file_path) - self.assertEquals(checker._handle_style_error, + self.assertEqual(checker._handle_style_error, self.mock_handle_style_error) def test_none_paths(self): @@ -625,10 +625,10 @@ class StyleProcessorConfigurationTest(unittest.TestCase): configuration = self._style_checker_configuration() # Check that __init__ sets the "public" data attributes correctly. - self.assertEquals(configuration.max_reports_per_category, + self.assertEqual(configuration.max_reports_per_category, {"whitespace/newline": 1}) - self.assertEquals(configuration.stderr_write, self._mock_stderr_write) - self.assertEquals(configuration.min_confidence, 3) + self.assertEqual(configuration.stderr_write, self._mock_stderr_write) + self.assertEqual(configuration.min_confidence, 3) def test_is_reportable(self): """Test the is_reportable() method.""" @@ -653,13 +653,13 @@ class StyleProcessorConfigurationTest(unittest.TestCase): def test_write_style_error_emacs(self): """Test the write_style_error() method.""" self._call_write_style_error("emacs") - self.assertEquals(self._error_messages, + self.assertEqual(self._error_messages, ["foo.h:100: message [whitespace/tab] [5]\n"]) def test_write_style_error_vs7(self): """Test the write_style_error() method.""" self._call_write_style_error("vs7") - self.assertEquals(self._error_messages, + self.assertEqual(self._error_messages, ["foo.h(100): message [whitespace/tab] [5]\n"]) @@ -685,8 +685,8 @@ class StyleProcessor_EndToEndTest(LoggingTestCase): stderr_write=self._mock_stderr_write) processor = StyleProcessor(configuration) - self.assertEquals(processor.error_count, 0) - self.assertEquals(self._messages, []) + self.assertEqual(processor.error_count, 0) + self.assertEqual(self._messages, []) def test_process(self): configuration = StyleProcessorConfiguration( @@ -699,10 +699,10 @@ class StyleProcessor_EndToEndTest(LoggingTestCase): processor.process(lines=['line1', 'Line with tab:\t'], file_path='foo.txt') - self.assertEquals(processor.error_count, 1) + self.assertEqual(processor.error_count, 1) expected_messages = ['foo.txt(2): Line contains tab character. ' '[whitespace/tab] [5]\n'] - self.assertEquals(self._messages, expected_messages) + self.assertEqual(self._messages, expected_messages) class StyleProcessor_CodeCoverageTest(LoggingTestCase): @@ -861,18 +861,18 @@ class StyleProcessor_CodeCoverageTest(LoggingTestCase): # Check that the carriage-return checker was instantiated correctly # and was passed lines correctly. carriage_checker = self.carriage_checker - self.assertEquals(carriage_checker.style_error_handler, + self.assertEqual(carriage_checker.style_error_handler, expected_error_handler) - self.assertEquals(carriage_checker.lines, ['line1', 'line2']) + self.assertEqual(carriage_checker.lines, ['line1', 'line2']) # Check that the style checker was dispatched correctly and was # passed lines correctly. checker = self._mock_dispatcher.dispatched_checker - self.assertEquals(checker.file_path, 'foo.txt') - self.assertEquals(checker.min_confidence, 3) - self.assertEquals(checker.style_error_handler, expected_error_handler) + self.assertEqual(checker.file_path, 'foo.txt') + self.assertEqual(checker.min_confidence, 3) + self.assertEqual(checker.style_error_handler, expected_error_handler) - self.assertEquals(checker.lines, ['line1', 'line2']) + self.assertEqual(checker.lines, ['line1', 'line2']) def test_process__no_checker_dispatched(self): """Test the process() method for a path with no dispatched checker.""" diff --git a/Tools/Scripts/webkitpy/style/checkers/changelog_unittest.py b/Tools/Scripts/webkitpy/style/checkers/changelog_unittest.py index 9fe8a60bc..315cd91b2 100644 --- a/Tools/Scripts/webkitpy/style/checkers/changelog_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/changelog_unittest.py @@ -44,8 +44,8 @@ class ChangeLogCheckerTest(unittest.TestCase): def handle_style_error(line_number, category, confidence, message): self.had_error = True - self.assertEquals(expected_line_number, line_number) - self.assertEquals(expected_category, category) + self.assertEqual(expected_line_number, line_number) + self.assertEqual(expected_category, category) self.lines_to_check = set(lines_to_check) checker = changelog.ChangeLogChecker('ChangeLog', handle_style_error, self.mock_should_line_be_checked) checker.check(changelog_data.split('\n')) @@ -59,9 +59,9 @@ class ChangeLogCheckerTest(unittest.TestCase): def test_init(self): checker = changelog.ChangeLogChecker('ChangeLog', self.mock_handle_style_error, self.mock_should_line_be_checked) - self.assertEquals(checker.file_path, 'ChangeLog') - self.assertEquals(checker.handle_style_error, self.mock_handle_style_error) - self.assertEquals(checker.should_line_be_checked, self.mock_should_line_be_checked) + self.assertEqual(checker.file_path, 'ChangeLog') + self.assertEqual(checker.handle_style_error, self.mock_handle_style_error) + self.assertEqual(checker.should_line_be_checked, self.mock_should_line_be_checked) def test_missing_bug_number(self): self.assert_error(1, range(1, 20), 'changelog/bugnumber', diff --git a/Tools/Scripts/webkitpy/style/checkers/common_unittest.py b/Tools/Scripts/webkitpy/style/checkers/common_unittest.py index 1fe126372..df4707730 100644 --- a/Tools/Scripts/webkitpy/style/checkers/common_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/common_unittest.py @@ -59,12 +59,12 @@ class CarriageReturnCheckerTest(unittest.TestCase): output_lines = checker.check(input_lines) # Check both the return value and error messages. - self.assertEquals(output_lines, expected_lines) + self.assertEqual(output_lines, expected_lines) expected_errors = [(line_number, self._category, self._confidence, self._expected_message) for line_number in error_lines] - self.assertEquals(self._style_errors, expected_errors) + self.assertEqual(self._style_errors, expected_errors) def test_ends_with_carriage(self): self.assert_carriage_return(["carriage return\r"], @@ -110,7 +110,7 @@ class TabCheckerTest(unittest.TestCase): checker = TabChecker('', style_error_handler) checker.check(input_lines) - self.assertEquals(self._error_lines, error_lines) + self.assertEqual(self._error_lines, error_lines) def test_notab(self): self.assert_tab([''], []) diff --git a/Tools/Scripts/webkitpy/style/checkers/cpp.py b/Tools/Scripts/webkitpy/style/checkers/cpp.py index a1447e2fb..f9d534b8c 100644 --- a/Tools/Scripts/webkitpy/style/checkers/cpp.py +++ b/Tools/Scripts/webkitpy/style/checkers/cpp.py @@ -1078,7 +1078,7 @@ def check_posix_threading(clean_lines, line_number, error): line = clean_lines.elided[line_number] for single_thread_function, multithread_safe_function in _THREADING_LIST: index = line.find(single_thread_function) - # Comparisons made explicit for clarity -- pylint: disable-msg=C6403 + # Comparisons made explicit for clarity if index >= 0 and (index == 0 or (not line[index - 1].isalnum() and line[index - 1] not in ('_', '.', '>'))): error(line_number, 'runtime/threadsafe_fn', 2, @@ -1793,7 +1793,7 @@ def check_spacing(file_extension, clean_lines, line_number, error): comment_position = line.find('//') if comment_position != -1: # Check if the // may be in quotes. If so, ignore it - # Comparisons made explicit for clarity -- pylint: disable-msg=C6403 + # Comparisons made explicit for clarity if (line.count('"', 0, comment_position) - line.count('\\"', 0, comment_position)) % 2 == 0: # not in quotes # Allow one space before end of line comment. if (not match(r'^\s*$', line[:comment_position]) diff --git a/Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py b/Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py index 552220101..6de7df619 100644 --- a/Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py @@ -116,17 +116,17 @@ class CppFunctionsTest(unittest.TestCase): """Supports testing functions that do not need CppStyleTestBase.""" def test_convert_to_lower_with_underscores(self): - self.assertEquals(cpp_style._convert_to_lower_with_underscores('ABC'), 'abc') - self.assertEquals(cpp_style._convert_to_lower_with_underscores('aB'), 'a_b') - self.assertEquals(cpp_style._convert_to_lower_with_underscores('isAName'), 'is_a_name') - self.assertEquals(cpp_style._convert_to_lower_with_underscores('AnotherTest'), 'another_test') - self.assertEquals(cpp_style._convert_to_lower_with_underscores('PassRefPtr<MyClass>'), 'pass_ref_ptr<my_class>') - self.assertEquals(cpp_style._convert_to_lower_with_underscores('_ABC'), '_abc') + self.assertEqual(cpp_style._convert_to_lower_with_underscores('ABC'), 'abc') + self.assertEqual(cpp_style._convert_to_lower_with_underscores('aB'), 'a_b') + self.assertEqual(cpp_style._convert_to_lower_with_underscores('isAName'), 'is_a_name') + self.assertEqual(cpp_style._convert_to_lower_with_underscores('AnotherTest'), 'another_test') + self.assertEqual(cpp_style._convert_to_lower_with_underscores('PassRefPtr<MyClass>'), 'pass_ref_ptr<my_class>') + self.assertEqual(cpp_style._convert_to_lower_with_underscores('_ABC'), '_abc') def test_create_acronym(self): - self.assertEquals(cpp_style._create_acronym('ABC'), 'ABC') - self.assertEquals(cpp_style._create_acronym('IsAName'), 'IAN') - self.assertEquals(cpp_style._create_acronym('PassRefPtr<MyClass>'), 'PRP<MC>') + self.assertEqual(cpp_style._create_acronym('ABC'), 'ABC') + self.assertEqual(cpp_style._create_acronym('IsAName'), 'IAN') + self.assertEqual(cpp_style._create_acronym('PassRefPtr<MyClass>'), 'PRP<MC>') def test_is_c_or_objective_c(self): clean_lines = cpp_style.CleansedLines(['']) @@ -141,68 +141,68 @@ class CppFunctionsTest(unittest.TestCase): def test_parameter(self): # Test type. parameter = cpp_style.Parameter('ExceptionCode', 13, 1) - self.assertEquals(parameter.type, 'ExceptionCode') - self.assertEquals(parameter.name, '') - self.assertEquals(parameter.row, 1) + self.assertEqual(parameter.type, 'ExceptionCode') + self.assertEqual(parameter.name, '') + self.assertEqual(parameter.row, 1) # Test type and name. parameter = cpp_style.Parameter('PassRefPtr<MyClass> parent', 19, 1) - self.assertEquals(parameter.type, 'PassRefPtr<MyClass>') - self.assertEquals(parameter.name, 'parent') - self.assertEquals(parameter.row, 1) + self.assertEqual(parameter.type, 'PassRefPtr<MyClass>') + self.assertEqual(parameter.name, 'parent') + self.assertEqual(parameter.row, 1) # Test type, no name, with default value. parameter = cpp_style.Parameter('MyClass = 0', 7, 0) - self.assertEquals(parameter.type, 'MyClass') - self.assertEquals(parameter.name, '') - self.assertEquals(parameter.row, 0) + self.assertEqual(parameter.type, 'MyClass') + self.assertEqual(parameter.name, '') + self.assertEqual(parameter.row, 0) # Test type, name, and default value. parameter = cpp_style.Parameter('MyClass a = 0', 7, 0) - self.assertEquals(parameter.type, 'MyClass') - self.assertEquals(parameter.name, 'a') - self.assertEquals(parameter.row, 0) + self.assertEqual(parameter.type, 'MyClass') + self.assertEqual(parameter.name, 'a') + self.assertEqual(parameter.row, 0) def test_single_line_view(self): start_position = cpp_style.Position(row=1, column=1) end_position = cpp_style.Position(row=3, column=1) single_line_view = cpp_style.SingleLineView(['0', 'abcde', 'fgh', 'i'], start_position, end_position) - self.assertEquals(single_line_view.single_line, 'bcde fgh i') - self.assertEquals(single_line_view.convert_column_to_row(0), 1) - self.assertEquals(single_line_view.convert_column_to_row(4), 1) - self.assertEquals(single_line_view.convert_column_to_row(5), 2) - self.assertEquals(single_line_view.convert_column_to_row(8), 2) - self.assertEquals(single_line_view.convert_column_to_row(9), 3) - self.assertEquals(single_line_view.convert_column_to_row(100), 3) + self.assertEqual(single_line_view.single_line, 'bcde fgh i') + self.assertEqual(single_line_view.convert_column_to_row(0), 1) + self.assertEqual(single_line_view.convert_column_to_row(4), 1) + self.assertEqual(single_line_view.convert_column_to_row(5), 2) + self.assertEqual(single_line_view.convert_column_to_row(8), 2) + self.assertEqual(single_line_view.convert_column_to_row(9), 3) + self.assertEqual(single_line_view.convert_column_to_row(100), 3) start_position = cpp_style.Position(row=0, column=3) end_position = cpp_style.Position(row=0, column=4) single_line_view = cpp_style.SingleLineView(['abcdef'], start_position, end_position) - self.assertEquals(single_line_view.single_line, 'd') + self.assertEqual(single_line_view.single_line, 'd') def test_create_skeleton_parameters(self): - self.assertEquals(cpp_style.create_skeleton_parameters(''), '') - self.assertEquals(cpp_style.create_skeleton_parameters(' '), ' ') - self.assertEquals(cpp_style.create_skeleton_parameters('long'), 'long,') - self.assertEquals(cpp_style.create_skeleton_parameters('const unsigned long int'), ' int,') - self.assertEquals(cpp_style.create_skeleton_parameters('long int*'), ' int ,') - self.assertEquals(cpp_style.create_skeleton_parameters('PassRefPtr<Foo> a'), 'PassRefPtr a,') - self.assertEquals(cpp_style.create_skeleton_parameters( + self.assertEqual(cpp_style.create_skeleton_parameters(''), '') + self.assertEqual(cpp_style.create_skeleton_parameters(' '), ' ') + self.assertEqual(cpp_style.create_skeleton_parameters('long'), 'long,') + self.assertEqual(cpp_style.create_skeleton_parameters('const unsigned long int'), ' int,') + self.assertEqual(cpp_style.create_skeleton_parameters('long int*'), ' int ,') + self.assertEqual(cpp_style.create_skeleton_parameters('PassRefPtr<Foo> a'), 'PassRefPtr a,') + self.assertEqual(cpp_style.create_skeleton_parameters( 'ComplexTemplate<NestedTemplate1<MyClass1, MyClass2>, NestedTemplate1<MyClass1, MyClass2> > param, int second'), 'ComplexTemplate param, int second,') - self.assertEquals(cpp_style.create_skeleton_parameters('int = 0, Namespace::Type& a'), 'int , Type a,') + self.assertEqual(cpp_style.create_skeleton_parameters('int = 0, Namespace::Type& a'), 'int , Type a,') # Create skeleton parameters is a bit too aggressive with function variables, but # it allows for parsing other parameters and declarations like this are rare. - self.assertEquals(cpp_style.create_skeleton_parameters('void (*fn)(int a, int b), Namespace::Type& a'), + self.assertEqual(cpp_style.create_skeleton_parameters('void (*fn)(int a, int b), Namespace::Type& a'), 'void , Type a,') # This doesn't look like functions declarations but the simplifications help to eliminate false positives. - self.assertEquals(cpp_style.create_skeleton_parameters('b{d}'), 'b ,') + self.assertEqual(cpp_style.create_skeleton_parameters('b{d}'), 'b ,') def test_find_parameter_name_index(self): - self.assertEquals(cpp_style.find_parameter_name_index(' int a '), 5) - self.assertEquals(cpp_style.find_parameter_name_index(' PassRefPtr '), 16) - self.assertEquals(cpp_style.find_parameter_name_index('double'), 6) + self.assertEqual(cpp_style.find_parameter_name_index(' int a '), 5) + self.assertEqual(cpp_style.find_parameter_name_index(' PassRefPtr '), 16) + self.assertEqual(cpp_style.find_parameter_name_index('double'), 6) def test_parameter_list(self): elided_lines = ['int blah(PassRefPtr<MyClass> paramName,', @@ -219,17 +219,17 @@ class CppFunctionsTest(unittest.TestCase): index = 0 for parameter in cpp_style.parameter_list(elided_lines, start_position, end_position): expected_parameter = expected_parameters[index] - self.assertEquals(parameter.type, expected_parameter['type']) - self.assertEquals(parameter.name, expected_parameter['name']) - self.assertEquals(parameter.row, expected_parameter['row']) + self.assertEqual(parameter.type, expected_parameter['type']) + self.assertEqual(parameter.name, expected_parameter['name']) + self.assertEqual(parameter.row, expected_parameter['row']) index += 1 - self.assertEquals(index, len(expected_parameters)) + self.assertEqual(index, len(expected_parameters)) def test_check_parameter_against_text(self): - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) parameter = cpp_style.Parameter('FooF ooF', 4, 1) self.assertFalse(cpp_style._check_parameter_name_against_text(parameter, 'FooF', error_collector)) - self.assertEquals(error_collector.results(), + self.assertEqual(error_collector.results(), 'The parameter name "ooF" adds no information, so it should be removed. [readability/parameter_name] [5]') class CppStyleTestBase(unittest.TestCase): @@ -253,7 +253,7 @@ class CppStyleTestBase(unittest.TestCase): error, self.min_confidence, unit_test_config) def perform_lint(self, code, filename, basic_error_rules, unit_test_config={}, lines_to_check=None): - error_collector = ErrorCollector(self.assert_, FilterConfiguration(basic_error_rules), lines_to_check) + error_collector = ErrorCollector(self.assertTrue, FilterConfiguration(basic_error_rules), lines_to_check) lines = code.split('\n') extension = filename.split('.')[1] self.process_file_data(filename, extension, lines, error_collector, unit_test_config) @@ -313,7 +313,7 @@ class CppStyleTestBase(unittest.TestCase): # Perform lint and compare the error message with "expected_message". def assert_lint(self, code, expected_message, file_name='foo.cpp'): - self.assertEquals(expected_message, self.perform_single_line_lint(code, file_name)) + self.assertEqual(expected_message, self.perform_single_line_lint(code, file_name)) def assert_lint_one_of_many_errors_re(self, code, expected_message_re, file_name='foo.cpp'): messages = self.perform_single_line_lint(code, file_name) @@ -321,11 +321,11 @@ class CppStyleTestBase(unittest.TestCase): if re.search(expected_message_re, message): return - self.assertEquals(expected_message_re, messages) + self.assertEqual(expected_message_re, messages) def assert_multi_line_lint(self, code, expected_message, file_name='foo.h'): file_extension = file_name[file_name.rfind('.') + 1:] - self.assertEquals(expected_message, self.perform_multi_line_lint(code, file_extension)) + self.assertEqual(expected_message, self.perform_multi_line_lint(code, file_extension)) def assert_multi_line_lint_re(self, code, expected_message_re, file_name='foo.h'): file_extension = file_name[file_name.rfind('.') + 1:] @@ -334,22 +334,22 @@ class CppStyleTestBase(unittest.TestCase): self.fail('Message was:\n' + message + 'Expected match to "' + expected_message_re + '"') def assert_language_rules_check(self, file_name, code, expected_message, lines_to_check=None): - self.assertEquals(expected_message, + self.assertEqual(expected_message, self.perform_language_rules_check(file_name, code, lines_to_check)) def assert_include_what_you_use(self, code, expected_message): - self.assertEquals(expected_message, + self.assertEqual(expected_message, self.perform_include_what_you_use(code)) def assert_blank_lines_check(self, lines, start_errors, end_errors): - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data('foo.cpp', 'cpp', lines, error_collector) - self.assertEquals( + self.assertEqual( start_errors, error_collector.results().count( 'Blank line at the start of a code block. Is this needed?' ' [whitespace/blank_line] [2]')) - self.assertEquals( + self.assertEqual( end_errors, error_collector.results().count( 'Blank line at the end of a code block. Is this needed?' @@ -360,7 +360,7 @@ class CppStyleTestBase(unittest.TestCase): position: a cpp_style.Position object. tuple_position: a tuple (row, column) to compare against.""" - self.assertEquals(position, cpp_style.Position(tuple_position[0], tuple_position[1]), + self.assertEqual(position, cpp_style.Position(tuple_position[0], tuple_position[1]), 'position %s, tuple_position %s' % (position, tuple_position)) @@ -368,16 +368,16 @@ class FunctionDetectionTest(CppStyleTestBase): def perform_function_detection(self, lines, function_information, detection_line=0): clean_lines = cpp_style.CleansedLines(lines) function_state = cpp_style._FunctionState(5) - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) cpp_style.detect_functions(clean_lines, detection_line, function_state, error_collector) if not function_information: - self.assertEquals(function_state.in_a_function, False) + self.assertEqual(function_state.in_a_function, False) return - self.assertEquals(function_state.in_a_function, True) - self.assertEquals(function_state.current_function, function_information['name'] + '()') - self.assertEquals(function_state.modifiers_and_return_type(), function_information['modifiers_and_return_type']) - self.assertEquals(function_state.is_pure, function_information['is_pure']) - self.assertEquals(function_state.is_declaration, function_information['is_declaration']) + self.assertEqual(function_state.in_a_function, True) + self.assertEqual(function_state.current_function, function_information['name'] + '()') + self.assertEqual(function_state.modifiers_and_return_type(), function_information['modifiers_and_return_type']) + self.assertEqual(function_state.is_pure, function_information['is_pure']) + self.assertEqual(function_state.is_declaration, function_information['is_declaration']) self.assert_positions_equal(function_state.function_name_start_position, function_information['function_name_start_position']) self.assert_positions_equal(function_state.parameter_start_position, function_information['parameter_start_position']) self.assert_positions_equal(function_state.parameter_end_position, function_information['parameter_end_position']) @@ -386,13 +386,13 @@ class FunctionDetectionTest(CppStyleTestBase): expected_parameters = function_information.get('parameter_list') if expected_parameters: actual_parameters = function_state.parameter_list() - self.assertEquals(len(actual_parameters), len(expected_parameters)) + self.assertEqual(len(actual_parameters), len(expected_parameters)) for index in range(len(expected_parameters)): actual_parameter = actual_parameters[index] expected_parameter = expected_parameters[index] - self.assertEquals(actual_parameter.type, expected_parameter['type']) - self.assertEquals(actual_parameter.name, expected_parameter['name']) - self.assertEquals(actual_parameter.row, expected_parameter['row']) + self.assertEqual(actual_parameter.type, expected_parameter['type']) + self.assertEqual(actual_parameter.name, expected_parameter['name']) + self.assertEqual(actual_parameter.row, expected_parameter['row']) def test_basic_function_detection(self): self.perform_function_detection( @@ -634,54 +634,54 @@ class CppStyleTest(CppStyleTestBase): # Test get line width. def test_get_line_width(self): - self.assertEquals(0, cpp_style.get_line_width('')) - self.assertEquals(10, cpp_style.get_line_width(u'x' * 10)) - self.assertEquals(16, cpp_style.get_line_width(u'都|道|府|県|支庁')) + self.assertEqual(0, cpp_style.get_line_width('')) + self.assertEqual(10, cpp_style.get_line_width(u'x' * 10)) + self.assertEqual(16, cpp_style.get_line_width(u'都|道|府|県|支庁')) def test_find_next_multi_line_comment_start(self): - self.assertEquals(1, cpp_style.find_next_multi_line_comment_start([''], 0)) + self.assertEqual(1, cpp_style.find_next_multi_line_comment_start([''], 0)) lines = ['a', 'b', '/* c'] - self.assertEquals(2, cpp_style.find_next_multi_line_comment_start(lines, 0)) + self.assertEqual(2, cpp_style.find_next_multi_line_comment_start(lines, 0)) lines = ['char a[] = "/*";'] # not recognized as comment. - self.assertEquals(1, cpp_style.find_next_multi_line_comment_start(lines, 0)) + self.assertEqual(1, cpp_style.find_next_multi_line_comment_start(lines, 0)) def test_find_next_multi_line_comment_end(self): - self.assertEquals(1, cpp_style.find_next_multi_line_comment_end([''], 0)) + self.assertEqual(1, cpp_style.find_next_multi_line_comment_end([''], 0)) lines = ['a', 'b', ' c */'] - self.assertEquals(2, cpp_style.find_next_multi_line_comment_end(lines, 0)) + self.assertEqual(2, cpp_style.find_next_multi_line_comment_end(lines, 0)) def test_remove_multi_line_comments_from_range(self): lines = ['a', ' /* comment ', ' * still comment', ' comment */ ', 'b'] cpp_style.remove_multi_line_comments_from_range(lines, 1, 4) - self.assertEquals(['a', '// dummy', '// dummy', '// dummy', 'b'], lines) + self.assertEqual(['a', '// dummy', '// dummy', '// dummy', 'b'], lines) def test_position(self): position = cpp_style.Position(3, 4) self.assert_positions_equal(position, (3, 4)) - self.assertEquals(position.row, 3) + self.assertEqual(position.row, 3) self.assertTrue(position > cpp_style.Position(position.row - 1, position.column + 1)) self.assertTrue(position > cpp_style.Position(position.row, position.column - 1)) self.assertTrue(position < cpp_style.Position(position.row, position.column + 1)) self.assertTrue(position < cpp_style.Position(position.row + 1, position.column - 1)) - self.assertEquals(position.__str__(), '(3, 4)') + self.assertEqual(position.__str__(), '(3, 4)') def test_rfind_in_lines(self): not_found_position = cpp_style.Position(10, 11) start_position = cpp_style.Position(2, 2) lines = ['ab', 'ace', 'test'] - self.assertEquals(not_found_position, cpp_style._rfind_in_lines('st', lines, start_position, not_found_position)) + self.assertEqual(not_found_position, cpp_style._rfind_in_lines('st', lines, start_position, not_found_position)) self.assertTrue(cpp_style.Position(1, 1) == cpp_style._rfind_in_lines('a', lines, start_position, not_found_position)) - self.assertEquals(cpp_style.Position(2, 2), cpp_style._rfind_in_lines('(te|a)', lines, start_position, not_found_position)) + self.assertEqual(cpp_style.Position(2, 2), cpp_style._rfind_in_lines('(te|a)', lines, start_position, not_found_position)) def test_close_expression(self): - self.assertEquals(cpp_style.Position(1, -1), cpp_style.close_expression([')('], cpp_style.Position(0, 1))) - self.assertEquals(cpp_style.Position(1, -1), cpp_style.close_expression([') ()'], cpp_style.Position(0, 1))) - self.assertEquals(cpp_style.Position(0, 4), cpp_style.close_expression([')[)]'], cpp_style.Position(0, 1))) - self.assertEquals(cpp_style.Position(0, 5), cpp_style.close_expression(['}{}{}'], cpp_style.Position(0, 3))) - self.assertEquals(cpp_style.Position(1, 1), cpp_style.close_expression(['}{}{', '}'], cpp_style.Position(0, 3))) - self.assertEquals(cpp_style.Position(2, -1), cpp_style.close_expression(['][][', ' '], cpp_style.Position(0, 3))) + self.assertEqual(cpp_style.Position(1, -1), cpp_style.close_expression([')('], cpp_style.Position(0, 1))) + self.assertEqual(cpp_style.Position(1, -1), cpp_style.close_expression([') ()'], cpp_style.Position(0, 1))) + self.assertEqual(cpp_style.Position(0, 4), cpp_style.close_expression([')[)]'], cpp_style.Position(0, 1))) + self.assertEqual(cpp_style.Position(0, 5), cpp_style.close_expression(['}{}{}'], cpp_style.Position(0, 3))) + self.assertEqual(cpp_style.Position(1, 1), cpp_style.close_expression(['}{}{', '}'], cpp_style.Position(0, 3))) + self.assertEqual(cpp_style.Position(2, -1), cpp_style.close_expression(['][][', ' '], cpp_style.Position(0, 3))) def test_spaces_at_end_of_line(self): self.assert_lint( @@ -864,10 +864,10 @@ class CppStyleTest(CppStyleTestBase): def test_include_what_you_use_no_implementation_files(self): code = 'std::vector<int> foo;' - self.assertEquals('Add #include <vector> for vector<>' + self.assertEqual('Add #include <vector> for vector<>' ' [build/include_what_you_use] [4]', self.perform_include_what_you_use(code, 'foo.h')) - self.assertEquals('', + self.assertEqual('', self.perform_include_what_you_use(code, 'foo.cpp')) def test_include_what_you_use(self): @@ -1003,7 +1003,7 @@ class CppStyleTest(CppStyleTestBase): '#include "blah/a.h"\n', filename='blah/a.cpp', io=MockIo(mock_header_contents)) - self.assertEquals(message, '') + self.assertEqual(message, '') mock_header_contents = ['#include <set>'] message = self.perform_include_what_you_use( @@ -1013,7 +1013,7 @@ class CppStyleTest(CppStyleTestBase): std::set<int> foo;''', filename='blah/a.cpp', io=MockIo(mock_header_contents)) - self.assertEquals(message, '') + self.assertEqual(message, '') # If there's just a .cpp and the header can't be found then it's ok. message = self.perform_include_what_you_use( @@ -1022,7 +1022,7 @@ class CppStyleTest(CppStyleTestBase): std::set<int> foo;''', filename='blah/a.cpp') - self.assertEquals(message, '') + self.assertEqual(message, '') # Make sure we find the headers with relative paths. mock_header_contents = [''] @@ -1033,40 +1033,40 @@ class CppStyleTest(CppStyleTestBase): std::set<int> foo;''' % (os.path.basename(os.getcwd()), os.path.sep), filename='a.cpp', io=MockIo(mock_header_contents)) - self.assertEquals(message, 'Add #include <set> for set<> ' + self.assertEqual(message, 'Add #include <set> for set<> ' '[build/include_what_you_use] [4]') def test_files_belong_to_same_module(self): f = cpp_style.files_belong_to_same_module - self.assertEquals((True, ''), f('a.cpp', 'a.h')) - self.assertEquals((True, ''), f('base/google.cpp', 'base/google.h')) - self.assertEquals((True, ''), f('base/google_test.cpp', 'base/google.h')) - self.assertEquals((True, ''), + self.assertEqual((True, ''), f('a.cpp', 'a.h')) + self.assertEqual((True, ''), f('base/google.cpp', 'base/google.h')) + self.assertEqual((True, ''), f('base/google_test.cpp', 'base/google.h')) + self.assertEqual((True, ''), f('base/google_unittest.cpp', 'base/google.h')) - self.assertEquals((True, ''), + self.assertEqual((True, ''), f('base/internal/google_unittest.cpp', 'base/public/google.h')) - self.assertEquals((True, 'xxx/yyy/'), + self.assertEqual((True, 'xxx/yyy/'), f('xxx/yyy/base/internal/google_unittest.cpp', 'base/public/google.h')) - self.assertEquals((True, 'xxx/yyy/'), + self.assertEqual((True, 'xxx/yyy/'), f('xxx/yyy/base/google_unittest.cpp', 'base/public/google.h')) - self.assertEquals((True, ''), + self.assertEqual((True, ''), f('base/google_unittest.cpp', 'base/google-inl.h')) - self.assertEquals((True, '/home/build/google3/'), + self.assertEqual((True, '/home/build/google3/'), f('/home/build/google3/base/google.cpp', 'base/google.h')) - self.assertEquals((False, ''), + self.assertEqual((False, ''), f('/home/build/google3/base/google.cpp', 'basu/google.h')) - self.assertEquals((False, ''), f('a.cpp', 'b.h')) + self.assertEqual((False, ''), f('a.cpp', 'b.h')) def test_cleanse_line(self): - self.assertEquals('int foo = 0; ', + self.assertEqual('int foo = 0; ', cpp_style.cleanse_comments('int foo = 0; // danger!')) - self.assertEquals('int o = 0;', + self.assertEqual('int o = 0;', cpp_style.cleanse_comments('int /* foo */ o = 0;')) - self.assertEquals('foo(int a, int b);', + self.assertEqual('foo(int a, int b);', cpp_style.cleanse_comments('foo(int a /* abc */, int b);')) self.assertEqual('f(a, b);', cpp_style.cleanse_comments('f(a, /* name */ b);')) @@ -1113,12 +1113,12 @@ class CppStyleTest(CppStyleTestBase): file_path = 'mydir/foo.cpp' - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data(file_path, 'cpp', ['const char* str = "This is a\\', ' multiline string.";'], error_collector) - self.assertEquals( + self.assertEqual( 2, # One per line. error_collector.result_list().count(multiline_string_error_message)) @@ -1902,11 +1902,11 @@ class CppStyleTest(CppStyleTestBase): def test_newline_at_eof(self): def do_test(self, data, is_missing_eof): - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data('foo.cpp', 'cpp', data.split('\n'), error_collector) # The warning appears only once. - self.assertEquals( + self.assertEqual( int(is_missing_eof), error_collector.results().count( 'Could not find a newline character at the end of the file.' @@ -1917,12 +1917,12 @@ class CppStyleTest(CppStyleTestBase): def test_invalid_utf8(self): def do_test(self, raw_bytes, has_invalid_utf8): - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data('foo.cpp', 'cpp', unicode(raw_bytes, 'utf8', 'replace').split('\n'), error_collector) # The warning appears only once. - self.assertEquals( + self.assertEqual( int(has_invalid_utf8), error_collector.results().count( 'Line contains invalid UTF-8' @@ -1937,11 +1937,11 @@ class CppStyleTest(CppStyleTestBase): do_test(self, '\xef\xbf\xbd\n', True) def test_is_blank_line(self): - self.assert_(cpp_style.is_blank_line('')) - self.assert_(cpp_style.is_blank_line(' ')) - self.assert_(cpp_style.is_blank_line(' \t\r\n')) - self.assert_(not cpp_style.is_blank_line('int a;')) - self.assert_(not cpp_style.is_blank_line('{')) + self.assertTrue(cpp_style.is_blank_line('')) + self.assertTrue(cpp_style.is_blank_line(' ')) + self.assertTrue(cpp_style.is_blank_line(' \t\r\n')) + self.assertTrue(not cpp_style.is_blank_line('int a;')) + self.assertTrue(not cpp_style.is_blank_line('{')) def test_blank_lines_check(self): self.assert_blank_lines_check(['{\n', '\n', '\n', '}\n'], 1, 1) @@ -1952,16 +1952,16 @@ class CppStyleTest(CppStyleTestBase): self.assert_blank_lines_check(['\n', ' if (foo) { return 0; }\n', '\n'], 0, 0) def test_allow_blank_line_before_closing_namespace(self): - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data('foo.cpp', 'cpp', ['namespace {', '', '} // namespace'], error_collector) - self.assertEquals(0, error_collector.results().count( + self.assertEqual(0, error_collector.results().count( 'Blank line at the end of a code block. Is this needed?' ' [whitespace/blank_line] [3]')) def test_allow_blank_line_before_if_else_chain(self): - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data('foo.cpp', 'cpp', ['if (hoge) {', '', # No warning @@ -1973,12 +1973,12 @@ class CppStyleTest(CppStyleTestBase): '', # Warning on this line '}'], error_collector) - self.assertEquals(1, error_collector.results().count( + self.assertEqual(1, error_collector.results().count( 'Blank line at the end of a code block. Is this needed?' ' [whitespace/blank_line] [3]')) def test_else_on_same_line_as_closing_braces(self): - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data('foo.cpp', 'cpp', ['if (hoge) {', '', @@ -1987,7 +1987,7 @@ class CppStyleTest(CppStyleTestBase): '', '}'], error_collector) - self.assertEquals(1, error_collector.results().count( + self.assertEqual(1, error_collector.results().count( 'An else should appear on the same line as the preceding }' ' [whitespace/newline] [4]')) @@ -2144,7 +2144,7 @@ class CppStyleTest(CppStyleTestBase): # side of things, so just parse out the suggested header guard. This # doesn't allow us to test the suggested header guard, but it does let us # test all the other header tests. - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data(file_path, 'h', [], error_collector) expected_guard = '' matcher = re.compile( @@ -2159,10 +2159,10 @@ class CppStyleTest(CppStyleTestBase): self.assertNotEqual(expected_guard, '') # Wrong guard - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data(file_path, 'h', ['#ifndef FOO_H', '#define FOO_H'], error_collector) - self.assertEquals( + self.assertEqual( 1, error_collector.result_list().count( '#ifndef header guard has wrong style, please use: %s' @@ -2170,10 +2170,10 @@ class CppStyleTest(CppStyleTestBase): error_collector.result_list()) # No define - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data(file_path, 'h', ['#ifndef %s' % expected_guard], error_collector) - self.assertEquals( + self.assertEqual( 1, error_collector.result_list().count( 'No #ifndef header guard found, suggested CPP variable is: %s' @@ -2181,12 +2181,12 @@ class CppStyleTest(CppStyleTestBase): error_collector.result_list()) # Mismatched define - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data(file_path, 'h', ['#ifndef %s' % expected_guard, '#define FOO_H'], error_collector) - self.assertEquals( + self.assertEqual( 1, error_collector.result_list().count( 'No #ifndef header guard found, suggested CPP variable is: %s' @@ -2194,7 +2194,7 @@ class CppStyleTest(CppStyleTestBase): error_collector.result_list()) # No header guard errors - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data(file_path, 'h', ['#ifndef %s' % expected_guard, '#define %s' % expected_guard, @@ -2205,13 +2205,13 @@ class CppStyleTest(CppStyleTestBase): self.fail('Unexpected error: %s' % line) # Completely incorrect header guard - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data(file_path, 'h', ['#ifndef FOO', '#define FOO', '#endif // FOO'], error_collector) - self.assertEquals( + self.assertEqual( 1, error_collector.result_list().count( '#ifndef header guard has wrong style, please use: %s' @@ -2219,7 +2219,7 @@ class CppStyleTest(CppStyleTestBase): error_collector.result_list()) # Special case for flymake - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data('mydir/Foo_flymake.h', 'h', ['#ifndef %s' % expected_guard, '#define %s' % expected_guard, @@ -2229,9 +2229,9 @@ class CppStyleTest(CppStyleTestBase): if line.find('build/header_guard') != -1: self.fail('Unexpected error: %s' % line) - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data('mydir/Foo_flymake.h', 'h', [], error_collector) - self.assertEquals( + self.assertEqual( 1, error_collector.result_list().count( 'No #ifndef header guard found, suggested CPP variable is: %s' @@ -2243,27 +2243,27 @@ class CppStyleTest(CppStyleTestBase): # Allow the WTF_ prefix for files in that directory. header_guard_filter = FilterConfiguration(('-', '+build/header_guard')) - error_collector = ErrorCollector(self.assert_, header_guard_filter) + error_collector = ErrorCollector(self.assertTrue, header_guard_filter) self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h', ['#ifndef WTF_TestName_h', '#define WTF_TestName_h'], error_collector) - self.assertEquals(0, len(error_collector.result_list()), + self.assertEqual(0, len(error_collector.result_list()), error_collector.result_list()) # Also allow the non WTF_ prefix for files in that directory. - error_collector = ErrorCollector(self.assert_, header_guard_filter) + error_collector = ErrorCollector(self.assertTrue, header_guard_filter) self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h', ['#ifndef TestName_h', '#define TestName_h'], error_collector) - self.assertEquals(0, len(error_collector.result_list()), + self.assertEqual(0, len(error_collector.result_list()), error_collector.result_list()) # Verify that we suggest the WTF prefix version. - error_collector = ErrorCollector(self.assert_, header_guard_filter) + error_collector = ErrorCollector(self.assertTrue, header_guard_filter) self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h', ['#ifndef BAD_TestName_h', '#define BAD_TestName_h'], error_collector) - self.assertEquals( + self.assertEqual( 1, error_collector.result_list().count( '#ifndef header guard has wrong style, please use: WTF_TestName_h' @@ -2403,29 +2403,29 @@ class CppStyleTest(CppStyleTestBase): file_path = 'mydir/googleclient/foo.cpp' # There should be a copyright message in the first 10 lines - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data(file_path, 'cpp', [], error_collector) - self.assertEquals( + self.assertEqual( 1, error_collector.result_list().count(legal_copyright_message)) - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data( file_path, 'cpp', ['' for unused_i in range(10)] + [copyright_line], error_collector) - self.assertEquals( + self.assertEqual( 1, error_collector.result_list().count(legal_copyright_message)) # Test that warning isn't issued if Copyright line appears early enough. - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data(file_path, 'cpp', [copyright_line], error_collector) for message in error_collector.result_list(): if message.find('legal/copyright') != -1: self.fail('Unexpected error: %s' % message) - error_collector = ErrorCollector(self.assert_) + error_collector = ErrorCollector(self.assertTrue) self.process_file_data( file_path, 'cpp', ['' for unused_i in range(9)] + [copyright_line], @@ -2457,16 +2457,16 @@ class CleansedLinesTest(unittest.TestCase): 'Line 4 "foo"'] clean_lines = cpp_style.CleansedLines(lines) - self.assertEquals(lines, clean_lines.raw_lines) - self.assertEquals(4, clean_lines.num_lines()) + self.assertEqual(lines, clean_lines.raw_lines) + self.assertEqual(4, clean_lines.num_lines()) - self.assertEquals(['Line 1', + self.assertEqual(['Line 1', 'Line 2', 'Line 3 ', 'Line 4 "foo"'], clean_lines.lines) - self.assertEquals(['Line 1', + self.assertEqual(['Line 1', 'Line 2', 'Line 3 ', 'Line 4 ""'], @@ -2474,33 +2474,33 @@ class CleansedLinesTest(unittest.TestCase): def test_init_empty(self): clean_lines = cpp_style.CleansedLines([]) - self.assertEquals([], clean_lines.raw_lines) - self.assertEquals(0, clean_lines.num_lines()) + self.assertEqual([], clean_lines.raw_lines) + self.assertEqual(0, clean_lines.num_lines()) def test_collapse_strings(self): collapse = cpp_style.CleansedLines.collapse_strings - self.assertEquals('""', collapse('""')) # "" (empty) - self.assertEquals('"""', collapse('"""')) # """ (bad) - self.assertEquals('""', collapse('"xyz"')) # "xyz" (string) - self.assertEquals('""', collapse('"\\\""')) # "\"" (string) - self.assertEquals('""', collapse('"\'"')) # "'" (string) - self.assertEquals('"\"', collapse('"\"')) # "\" (bad) - self.assertEquals('""', collapse('"\\\\"')) # "\\" (string) - self.assertEquals('"', collapse('"\\\\\\"')) # "\\\" (bad) - self.assertEquals('""', collapse('"\\\\\\\\"')) # "\\\\" (string) - - self.assertEquals('\'\'', collapse('\'\'')) # '' (empty) - self.assertEquals('\'\'', collapse('\'a\'')) # 'a' (char) - self.assertEquals('\'\'', collapse('\'\\\'\'')) # '\'' (char) - self.assertEquals('\'', collapse('\'\\\'')) # '\' (bad) - self.assertEquals('', collapse('\\012')) # '\012' (char) - self.assertEquals('', collapse('\\xfF0')) # '\xfF0' (char) - self.assertEquals('', collapse('\\n')) # '\n' (char) - self.assertEquals('\#', collapse('\\#')) # '\#' (bad) - - self.assertEquals('StringReplace(body, "", "");', + self.assertEqual('""', collapse('""')) # "" (empty) + self.assertEqual('"""', collapse('"""')) # """ (bad) + self.assertEqual('""', collapse('"xyz"')) # "xyz" (string) + self.assertEqual('""', collapse('"\\\""')) # "\"" (string) + self.assertEqual('""', collapse('"\'"')) # "'" (string) + self.assertEqual('"\"', collapse('"\"')) # "\" (bad) + self.assertEqual('""', collapse('"\\\\"')) # "\\" (string) + self.assertEqual('"', collapse('"\\\\\\"')) # "\\\" (bad) + self.assertEqual('""', collapse('"\\\\\\\\"')) # "\\\\" (string) + + self.assertEqual('\'\'', collapse('\'\'')) # '' (empty) + self.assertEqual('\'\'', collapse('\'a\'')) # 'a' (char) + self.assertEqual('\'\'', collapse('\'\\\'\'')) # '\'' (char) + self.assertEqual('\'', collapse('\'\\\'')) # '\' (bad) + self.assertEqual('', collapse('\\012')) # '\012' (char) + self.assertEqual('', collapse('\\xfF0')) # '\xfF0' (char) + self.assertEqual('', collapse('\\n')) # '\n' (char) + self.assertEqual('\#', collapse('\\#')) # '\#' (bad) + + self.assertEqual('StringReplace(body, "", "");', collapse('StringReplace(body, "\\\\", "\\\\\\\\");')) - self.assertEquals('\'\' ""', + self.assertEqual('\'\' ""', collapse('\'"\' "foo"')) @@ -2890,7 +2890,7 @@ class CheckForFunctionLengthsTest(CppStyleTestBase): code: C++ source code expected to generate a warning message. expected_message: Message expected to be generated by the C++ code. """ - self.assertEquals(expected_message, + self.assertEqual(expected_message, self.perform_function_lengths_check(code)) def trigger_lines(self, error_level): @@ -3346,7 +3346,7 @@ class PassPtrTest(CppStyleTestBase): code: C++ source code expected to generate a warning message. expected_message: Message expected to be generated by the C++ code. """ - self.assertEquals(expected_message, + self.assertEqual(expected_message, self.perform_pass_ptr_check(code)) def test_pass_ref_ptr_in_function(self): @@ -3461,7 +3461,7 @@ class LeakyPatternTest(CppStyleTestBase): code: C++ source code expected to generate a warning message. expected_message: Message expected to be generated by the C++ code. """ - self.assertEquals(expected_message, + self.assertEqual(expected_message, self.perform_leaky_pattern_check(code)) def test_get_dc(self): @@ -4688,45 +4688,45 @@ class WebKitStyleTest(CppStyleTestBase): parameter_error_rules = ('-', '+readability/parameter_name') # No variable name, so no error. - self.assertEquals('', + self.assertEqual('', self.perform_lint('void func(int);', 'test.cpp', parameter_error_rules)) # Verify that copying the name of the set function causes the error (with some odd casing). - self.assertEquals(meaningless_variable_name_error_message % 'itemCount', + self.assertEqual(meaningless_variable_name_error_message % 'itemCount', self.perform_lint('void setItemCount(size_t itemCount);', 'test.cpp', parameter_error_rules)) - self.assertEquals(meaningless_variable_name_error_message % 'abcCount', + self.assertEqual(meaningless_variable_name_error_message % 'abcCount', self.perform_lint('void setABCCount(size_t abcCount);', 'test.cpp', parameter_error_rules)) # Verify that copying a type name will trigger the warning (even if the type is a template parameter). - self.assertEquals(meaningless_variable_name_error_message % 'context', + self.assertEqual(meaningless_variable_name_error_message % 'context', self.perform_lint('void funct(PassRefPtr<ScriptExecutionContext> context);', 'test.cpp', parameter_error_rules)) # Verify that acronyms as variable names trigger the error (for both set functions and type names). - self.assertEquals(meaningless_variable_name_error_message % 'ec', + self.assertEqual(meaningless_variable_name_error_message % 'ec', self.perform_lint('void setExceptionCode(int ec);', 'test.cpp', parameter_error_rules)) - self.assertEquals(meaningless_variable_name_error_message % 'ec', + self.assertEqual(meaningless_variable_name_error_message % 'ec', self.perform_lint('void funct(ExceptionCode ec);', 'test.cpp', parameter_error_rules)) # 'object' alone, appended, or as part of an acronym is meaningless. - self.assertEquals(meaningless_variable_name_error_message % 'object', + self.assertEqual(meaningless_variable_name_error_message % 'object', self.perform_lint('void funct(RenderView object);', 'test.cpp', parameter_error_rules)) - self.assertEquals(meaningless_variable_name_error_message % 'viewObject', + self.assertEqual(meaningless_variable_name_error_message % 'viewObject', self.perform_lint('void funct(RenderView viewObject);', 'test.cpp', parameter_error_rules)) - self.assertEquals(meaningless_variable_name_error_message % 'rvo', + self.assertEqual(meaningless_variable_name_error_message % 'rvo', self.perform_lint('void funct(RenderView rvo);', 'test.cpp', parameter_error_rules)) # Check that r, g, b, and a are allowed. - self.assertEquals('', + self.assertEqual('', self.perform_lint('void setRGBAValues(int r, int g, int b, int a);', 'test.cpp', parameter_error_rules)) # Verify that a simple substring match isn't done which would cause false positives. - self.assertEquals('', + self.assertEqual('', self.perform_lint('void setNateLateCount(size_t elate);', 'test.cpp', parameter_error_rules)) - self.assertEquals('', + self.assertEqual('', self.perform_lint('void funct(NateLate elate);', 'test.cpp', parameter_error_rules)) # Don't have generate warnings for functions (only declarations). - self.assertEquals('', + self.assertEqual('', self.perform_lint('void funct(PassRefPtr<ScriptExecutionContext> context)\n' '{\n' '}\n', 'test.cpp', parameter_error_rules)) @@ -4743,33 +4743,33 @@ class WebKitStyleTest(CppStyleTestBase): def test_webkit_export_check(self): webkit_export_error_rules = ('-', '+readability/webkit_export') - self.assertEquals('', + self.assertEqual('', self.perform_lint('WEBKIT_EXPORT int foo();\n', 'WebKit/chromium/public/test.h', webkit_export_error_rules)) - self.assertEquals('', + self.assertEqual('', self.perform_lint('WEBKIT_EXPORT int foo();\n', 'WebKit/chromium/tests/test.h', webkit_export_error_rules)) - self.assertEquals('WEBKIT_EXPORT should only be used in header files. [readability/webkit_export] [5]', + self.assertEqual('WEBKIT_EXPORT should only be used in header files. [readability/webkit_export] [5]', self.perform_lint('WEBKIT_EXPORT int foo();\n', 'WebKit/chromium/public/test.cpp', webkit_export_error_rules)) - self.assertEquals('WEBKIT_EXPORT should only appear in the chromium public (or tests) directory. [readability/webkit_export] [5]', + self.assertEqual('WEBKIT_EXPORT should only appear in the chromium public (or tests) directory. [readability/webkit_export] [5]', self.perform_lint('WEBKIT_EXPORT int foo();\n', 'WebKit/chromium/src/test.h', webkit_export_error_rules)) - self.assertEquals('WEBKIT_EXPORT should not be used on a function with a body. [readability/webkit_export] [5]', + self.assertEqual('WEBKIT_EXPORT should not be used on a function with a body. [readability/webkit_export] [5]', self.perform_lint('WEBKIT_EXPORT int foo() { }\n', 'WebKit/chromium/public/test.h', webkit_export_error_rules)) - self.assertEquals('WEBKIT_EXPORT should not be used on a function with a body. [readability/webkit_export] [5]', + self.assertEqual('WEBKIT_EXPORT should not be used on a function with a body. [readability/webkit_export] [5]', self.perform_lint('WEBKIT_EXPORT inline int foo()\n' '{\n' '}\n', 'WebKit/chromium/public/test.h', webkit_export_error_rules)) - self.assertEquals('WEBKIT_EXPORT should not be used with a pure virtual function. [readability/webkit_export] [5]', + self.assertEqual('WEBKIT_EXPORT should not be used with a pure virtual function. [readability/webkit_export] [5]', self.perform_lint('{}\n' 'WEBKIT_EXPORT\n' 'virtual\n' @@ -4777,7 +4777,7 @@ class WebKitStyleTest(CppStyleTestBase): 'foo() = 0;\n', 'WebKit/chromium/public/test.h', webkit_export_error_rules)) - self.assertEquals('', + self.assertEqual('', self.perform_lint('{}\n' 'WEBKIT_EXPORT\n' 'virtual\n' @@ -4804,10 +4804,10 @@ class CppCheckerTest(unittest.TestCase): def test_init(self): """Test __init__ constructor.""" checker = self._checker() - self.assertEquals(checker.file_extension, "h") - self.assertEquals(checker.file_path, "foo") - self.assertEquals(checker.handle_style_error, self.mock_handle_style_error) - self.assertEquals(checker.min_confidence, 3) + self.assertEqual(checker.file_extension, "h") + self.assertEqual(checker.file_path, "foo") + self.assertEqual(checker.handle_style_error, self.mock_handle_style_error) + self.assertEqual(checker.min_confidence, 3) def test_eq(self): """Test __eq__ equality function.""" diff --git a/Tools/Scripts/webkitpy/style/checkers/jsonchecker_unittest.py b/Tools/Scripts/webkitpy/style/checkers/jsonchecker_unittest.py index 973c67384..e7fbbb42c 100755 --- a/Tools/Scripts/webkitpy/style/checkers/jsonchecker_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/jsonchecker_unittest.py @@ -67,8 +67,8 @@ class JSONCheckerTest(unittest.TestCase): def assert_error(self, expected_line_number, expected_category, json_data): def handle_style_error(mock_error_handler, line_number, category, confidence, message): mock_error_handler.had_error = True - self.assertEquals(expected_line_number, line_number) - self.assertEquals(expected_category, category) + self.assertEqual(expected_line_number, line_number) + self.assertEqual(expected_category, category) self.assertTrue(category in jsonchecker.JSONChecker.categories) error_handler = MockErrorHandler(handle_style_error) @@ -91,7 +91,7 @@ class JSONCheckerTest(unittest.TestCase): def test_init(self): error_handler = MockErrorHandler(self.mock_handle_style_error) checker = jsonchecker.JSONChecker('foo.json', error_handler) - self.assertEquals(checker._handle_style_error, error_handler) + self.assertEqual(checker._handle_style_error, error_handler) def test_no_error(self): self.assert_no_error("""{ diff --git a/Tools/Scripts/webkitpy/style/checkers/png_unittest.py b/Tools/Scripts/webkitpy/style/checkers/png_unittest.py index 764c28591..92b5ba448 100644 --- a/Tools/Scripts/webkitpy/style/checkers/png_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/png_unittest.py @@ -52,8 +52,8 @@ class PNGCheckerTest(unittest.TestCase): pass checker = PNGChecker("test/config", mock_handle_style_error, MockSCMDetector('git'), MockSystemHost()) - self.assertEquals(checker._file_path, "test/config") - self.assertEquals(checker._handle_style_error, mock_handle_style_error) + self.assertEqual(checker._file_path, "test/config") + self.assertEqual(checker._handle_style_error, mock_handle_style_error) def test_check(self): errors = [] @@ -69,8 +69,8 @@ class PNGCheckerTest(unittest.TestCase): scm = MockSCMDetector('svn') checker = PNGChecker(file_path, mock_handle_style_error, scm, MockSystemHost(filesystem=fs)) checker.check() - self.assertEquals(len(errors), 1) - self.assertEquals(errors[0], + self.assertEqual(len(errors), 1) + self.assertEqual(errors[0], (0, 'image/png', 5, 'Set the svn:mime-type property (svn propset svn:mime-type image/png ).')) files = {'/Users/mock/.subversion/config': 'enable-auto-props = yes\n*.png = svn:mime-type=image/png'} @@ -79,7 +79,7 @@ class PNGCheckerTest(unittest.TestCase): errors = [] checker = PNGChecker("config", mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() - self.assertEquals(len(errors), 0) + self.assertEqual(len(errors), 0) files = {'/Users/mock/.subversion/config': '#enable-auto-props = yes'} fs = MockFileSystem(files) @@ -87,7 +87,7 @@ class PNGCheckerTest(unittest.TestCase): errors = [] checker = PNGChecker("config", mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() - self.assertEquals(len(errors), 1) + self.assertEqual(len(errors), 1) files = {'/Users/mock/.subversion/config': 'enable-auto-props = yes\n#enable-auto-props = yes\n*.png = svn:mime-type=image/png'} fs = MockFileSystem(files) @@ -95,7 +95,7 @@ class PNGCheckerTest(unittest.TestCase): errors = [] checker = PNGChecker("config", mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() - self.assertEquals(len(errors), 0) + self.assertEqual(len(errors), 0) files = {'/Users/mock/.subversion/config': '#enable-auto-props = yes\nenable-auto-props = yes\n*.png = svn:mime-type=image/png'} fs = MockFileSystem(files) @@ -103,7 +103,7 @@ class PNGCheckerTest(unittest.TestCase): errors = [] checker = PNGChecker("config", mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() - self.assertEquals(len(errors), 0) + self.assertEqual(len(errors), 0) files = {'/Users/mock/.subversion/config': 'enable-auto-props = no'} fs = MockFileSystem(files) @@ -111,7 +111,7 @@ class PNGCheckerTest(unittest.TestCase): errors = [] checker = PNGChecker("config", mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() - self.assertEquals(len(errors), 1) + self.assertEqual(len(errors), 1) file_path = "foo.png" fs.write_binary_file(file_path, "Dummy binary data") @@ -119,7 +119,7 @@ class PNGCheckerTest(unittest.TestCase): errors = [] checker = PNGChecker(file_path, mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() - self.assertEquals(len(errors), 1) + self.assertEqual(len(errors), 1) file_path = "foo-expected.png" fs.write_binary_file(file_path, "Dummy binary data") @@ -127,8 +127,8 @@ class PNGCheckerTest(unittest.TestCase): errors = [] checker = PNGChecker(file_path, mock_handle_style_error, scm, MockSystemHost(os_name='linux', filesystem=fs)) checker.check() - self.assertEquals(len(errors), 2) - self.assertEquals(errors[0], (0, 'image/png', 5, 'Image lacks a checksum. Generate pngs using run-webkit-tests to ensure they have a checksum.')) + self.assertEqual(len(errors), 2) + self.assertEqual(errors[0], (0, 'image/png', 5, 'Image lacks a checksum. Generate pngs using run-webkit-tests to ensure they have a checksum.')) if __name__ == '__main__': unittest.main() diff --git a/Tools/Scripts/webkitpy/style/checkers/python.py b/Tools/Scripts/webkitpy/style/checkers/python.py index 8cfd1b2d3..9fc436f3d 100644 --- a/Tools/Scripts/webkitpy/style/checkers/python.py +++ b/Tools/Scripts/webkitpy/style/checkers/python.py @@ -22,23 +22,32 @@ """Supports checking WebKit style in Python files.""" +import re +from StringIO import StringIO + +from webkitpy.common.system.filesystem import FileSystem +from webkitpy.common.webkit_finder import WebKitFinder from webkitpy.thirdparty.autoinstalled import pep8 +from webkitpy.thirdparty.autoinstalled.pylint import lint +from webkitpy.thirdparty.autoinstalled.pylint.reporters.text import ParseableTextReporter class PythonChecker(object): - """Processes text lines for checking style.""" - def __init__(self, file_path, handle_style_error): self._file_path = file_path self._handle_style_error = handle_style_error def check(self, lines): + self._check_pep8(lines) + self._check_pylint(lines) + + def _check_pep8(self, lines): # Initialize pep8.options, which is necessary for # Checker.check_all() to execute. pep8.process_options(arglist=[self._file_path]) - checker = pep8.Checker(self._file_path) + pep8_checker = pep8.Checker(self._file_path) def _pep8_handle_error(line_number, offset, text, check): # FIXME: Incorporate the character offset into the error output. @@ -51,6 +60,69 @@ class PythonChecker(object): self._handle_style_error(line_number, category, 5, pep8_message) - checker.report_error = _pep8_handle_error + pep8_checker.report_error = _pep8_handle_error + pep8_errors = pep8_checker.check_all() + + def _check_pylint(self, lines): + pylinter = Pylinter() + + # FIXME: for now, we only report pylint errors, but we should be catching and + # filtering warnings using the rules in style/checker.py instead. + output = pylinter.run(['-E', self._file_path]) + + lint_regex = re.compile('([^:]+):([^:]+): \[([^]]+)\] (.*)') + for error in output.getvalue().splitlines(): + match_obj = lint_regex.match(error) + assert(match_obj) + line_number = int(match_obj.group(2)) + category_and_method = match_obj.group(3).split(', ') + category = 'pylint/' + (category_and_method[0]) + if len(category_and_method) > 1: + message = '[%s] %s' % (category_and_method[1], match_obj.group(4)) + else: + message = match_obj.group(4) + self._handle_style_error(line_number, category, 5, message) + + +class Pylinter(object): + # We filter out these messages because they are bugs in pylint that produce false positives. + # FIXME: Does it make sense to combine these rules with the rules in style/checker.py somehow? + FALSE_POSITIVES = [ + # possibly http://www.logilab.org/ticket/98613 ? + "Instance of 'Popen' has no 'poll' member", + "Instance of 'Popen' has no 'returncode' member", + "Instance of 'Popen' has no 'stdin' member", + "Instance of 'Popen' has no 'stdout' member", + "Instance of 'Popen' has no 'stderr' member", + "Instance of 'Popen' has no 'wait' member", + ] + + def __init__(self): + self._pylintrc = WebKitFinder(FileSystem()).path_from_webkit_base('Tools', 'Scripts', 'webkitpy', 'pylintrc') + + def run(self, argv): + output = _FilteredStringIO(self.FALSE_POSITIVES) + lint.Run(['--rcfile', self._pylintrc] + argv, reporter=ParseableTextReporter(output=output), exit=False) + return output + + +class _FilteredStringIO(StringIO): + def __init__(self, bad_messages): + StringIO.__init__(self) + self.dropped_last_msg = False + self.bad_messages = bad_messages + + def write(self, msg=''): + if not self._filter(msg): + StringIO.write(self, msg) - errors = checker.check_all() + def _filter(self, msg): + if any(bad_message in msg for bad_message in self.bad_messages): + self.dropped_last_msg = True + return True + if self.dropped_last_msg: + # We drop the newline after a dropped message as well. + self.dropped_last_msg = False + if msg == '\n': + return True + return False diff --git a/Tools/Scripts/webkitpy/style/checkers/python_unittest.py b/Tools/Scripts/webkitpy/style/checkers/python_unittest.py index e003eb86d..73bda76e2 100644 --- a/Tools/Scripts/webkitpy/style/checkers/python_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/python_unittest.py @@ -38,8 +38,8 @@ class PythonCheckerTest(unittest.TestCase): pass checker = PythonChecker("foo.txt", _mock_handle_style_error) - self.assertEquals(checker._file_path, "foo.txt") - self.assertEquals(checker._handle_style_error, + self.assertEqual(checker._file_path, "foo.txt") + self.assertEqual(checker._handle_style_error, _mock_handle_style_error) def test_check(self): @@ -57,6 +57,7 @@ class PythonCheckerTest(unittest.TestCase): checker = PythonChecker(file_path, _mock_handle_style_error) checker.check(lines=[]) - self.assertEquals(len(errors), 1) - self.assertEquals(errors[0], - (2, "pep8/W291", 5, "trailing whitespace")) + self.assertEqual(errors, [ + (4, "pep8/W291", 5, "trailing whitespace"), + (4, "pylint/E0602", 5, "Undefined variable 'error'"), + ]) diff --git a/Tools/Scripts/webkitpy/style/checkers/python_unittest_input.py b/Tools/Scripts/webkitpy/style/checkers/python_unittest_input.py index 9f1d11848..afa1d4e22 100644 --- a/Tools/Scripts/webkitpy/style/checkers/python_unittest_input.py +++ b/Tools/Scripts/webkitpy/style/checkers/python_unittest_input.py @@ -1,2 +1,4 @@ -# This file is sample input for python_unittest.py and includes a single -# error which is an extra space at the end of this line. +# This file is sample input for python_unittest.py and includes two +# problems, one that will generate a PEP-8 warning for trailing whitespace +# and one that will generate a pylint error for an undefined variable. +print error() diff --git a/Tools/Scripts/webkitpy/style/checkers/test_expectations_unittest.py b/Tools/Scripts/webkitpy/style/checkers/test_expectations_unittest.py index 1516de797..b1d7f77f4 100644 --- a/Tools/Scripts/webkitpy/style/checkers/test_expectations_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/test_expectations_unittest.py @@ -71,7 +71,7 @@ class TestExpectationsTestCase(unittest.TestCase): if port: self.assertTrue(port.name().startswith(expected_port_implementation)) else: - self.assertEquals(None, expected_port_implementation) + self.assertEqual(None, expected_port_implementation) def test_determine_port_from_expectations_path(self): self._expect_port_for_expectations_path(None, '/') @@ -95,7 +95,7 @@ class TestExpectationsTestCase(unittest.TestCase): self._error_collector, host=host) # We should have failed to find a valid port object for that path. - self.assertEquals(checker._port_obj, None) + self.assertEqual(checker._port_obj, None) # Now use a test port so we can check the lines. checker._port_obj = host.port_factory.get('test-mac-leopard') @@ -105,7 +105,7 @@ class TestExpectationsTestCase(unittest.TestCase): if should_pass: self.assertEqual('', self._error_collector.get_errors()) elif expected_output: - self.assertEquals(expected_output, self._error_collector.get_errors()) + self.assertEqual(expected_output, self._error_collector.get_errors()) else: self.assertNotEquals('', self._error_collector.get_errors()) self.assertTrue(self._error_collector.turned_off_filtering) diff --git a/Tools/Scripts/webkitpy/style/checkers/text_unittest.py b/Tools/Scripts/webkitpy/style/checkers/text_unittest.py index ced49a943..18db6ad3d 100644 --- a/Tools/Scripts/webkitpy/style/checkers/text_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/text_unittest.py @@ -46,7 +46,7 @@ class TextStyleTestCase(unittest.TestCase): self.had_error = True text_style.process_file_data('', lines, error_for_test) - self.assert_(not self.had_error, '%s should not have any errors.' % lines) + self.assertTrue(not self.had_error, '%s should not have any errors.' % lines) def assertError(self, lines, expected_line_number): """Asserts that the specified lines has an error.""" @@ -54,12 +54,12 @@ class TextStyleTestCase(unittest.TestCase): def error_for_test(line_number, category, confidence, message): """Checks if the expected error occurs.""" - self.assertEquals(expected_line_number, line_number) - self.assertEquals('whitespace/tab', category) + self.assertEqual(expected_line_number, line_number) + self.assertEqual('whitespace/tab', category) self.had_error = True text_style.process_file_data('', lines, error_for_test) - self.assert_(self.had_error, '%s should have an error [whitespace/tab].' % lines) + self.assertTrue(self.had_error, '%s should have an error [whitespace/tab].' % lines) def test_no_error(self): @@ -86,8 +86,8 @@ class TextCheckerTest(unittest.TestCase): def test_init(self): """Test __init__ constructor.""" checker = TextChecker("foo.txt", self.mock_handle_style_error) - self.assertEquals(checker.file_path, "foo.txt") - self.assertEquals(checker.handle_style_error, self.mock_handle_style_error) + self.assertEqual(checker.file_path, "foo.txt") + self.assertEqual(checker.handle_style_error, self.mock_handle_style_error) if __name__ == '__main__': diff --git a/Tools/Scripts/webkitpy/style/checkers/watchlist_unittest.py b/Tools/Scripts/webkitpy/style/checkers/watchlist_unittest.py index c8d29db02..ff3a315f1 100644 --- a/Tools/Scripts/webkitpy/style/checkers/watchlist_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/watchlist_unittest.py @@ -56,8 +56,8 @@ class WatchListTest(unittest.TestCase): def test_basic_error_message(self): def handle_style_error(mock_error_handler, line_number, category, confidence, message): mock_error_handler.had_error = True - self.assertEquals(0, line_number) - self.assertEquals('watchlist/general', category) + self.assertEqual(0, line_number) + self.assertEqual('watchlist/general', category) error_handler = MockErrorHandler(handle_style_error) error_handler.had_error = False diff --git a/Tools/Scripts/webkitpy/style/checkers/xcodeproj_unittest.py b/Tools/Scripts/webkitpy/style/checkers/xcodeproj_unittest.py index 9799ec016..9713fd154 100644 --- a/Tools/Scripts/webkitpy/style/checkers/xcodeproj_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/xcodeproj_unittest.py @@ -62,7 +62,7 @@ class XcodeProjectFileCheckerTest(unittest.TestCase): error_handler = TestErrorHandler(handler) checker = xcodeproj.XcodeProjectFileChecker('', error_handler) checker.check(lines) - self.assert_(self.had_error, '%s should have error: %s.' % (lines, expected_message)) + self.assertTrue(self.had_error, '%s should have error: %s.' % (lines, expected_message)) def test_detect_development_region(self): self.assert_no_error(['developmentRegion = English;']) diff --git a/Tools/Scripts/webkitpy/style/checkers/xml_unittest.py b/Tools/Scripts/webkitpy/style/checkers/xml_unittest.py index e486f5fe4..7055a4f92 100644 --- a/Tools/Scripts/webkitpy/style/checkers/xml_unittest.py +++ b/Tools/Scripts/webkitpy/style/checkers/xml_unittest.py @@ -57,8 +57,8 @@ class XMLCheckerTest(unittest.TestCase): def assert_error(self, expected_line_number, expected_category, xml_data): def handle_style_error(mock_error_handler, line_number, category, confidence, message): mock_error_handler.had_error = True - self.assertEquals(expected_line_number, line_number) - self.assertEquals(expected_category, category) + self.assertEqual(expected_line_number, line_number) + self.assertEqual(expected_category, category) error_handler = MockErrorHandler(handle_style_error) error_handler.had_error = False @@ -80,7 +80,7 @@ class XMLCheckerTest(unittest.TestCase): def test_init(self): error_handler = MockErrorHandler(self.mock_handle_style_error) checker = xml.XMLChecker('foo.xml', error_handler) - self.assertEquals(checker._handle_style_error, error_handler) + self.assertEqual(checker._handle_style_error, error_handler) def test_missing_closing_tag(self): self.assert_error(3, 'xml/syntax', '<foo>\n<bar>\n</foo>\n') diff --git a/Tools/Scripts/webkitpy/style/error_handlers_unittest.py b/Tools/Scripts/webkitpy/style/error_handlers_unittest.py index 864bc0f7a..c02143178 100644 --- a/Tools/Scripts/webkitpy/style/error_handlers_unittest.py +++ b/Tools/Scripts/webkitpy/style/error_handlers_unittest.py @@ -70,8 +70,8 @@ class DefaultStyleErrorHandlerTest(unittest.TestCase): def _check_initialized(self): """Check that count and error messages are initialized.""" - self.assertEquals(0, self._error_count) - self.assertEquals(0, len(self._error_messages)) + self.assertEqual(0, self._error_count) + self.assertEqual(0, len(self._error_messages)) def _call_error_handler(self, handle_error, confidence, line_number=100): """Call the given error handler with a test error.""" @@ -131,8 +131,8 @@ class DefaultStyleErrorHandlerTest(unittest.TestCase): error_handler = self._error_handler(configuration) self._call_error_handler(error_handler, confidence) - self.assertEquals(0, self._error_count) - self.assertEquals([], self._error_messages) + self.assertEqual(0, self._error_count) + self.assertEqual([], self._error_messages) # Also serves as a reportable error test. def test_max_reports_per_category(self): @@ -145,27 +145,27 @@ class DefaultStyleErrorHandlerTest(unittest.TestCase): # First call: usual reporting. self._call_error_handler(error_handler, confidence) - self.assertEquals(1, self._error_count) - self.assertEquals(1, len(self._error_messages)) - self.assertEquals(self._error_messages, + self.assertEqual(1, self._error_count) + self.assertEqual(1, len(self._error_messages)) + self.assertEqual(self._error_messages, ["foo.h(100): message [whitespace/tab] [5]\n"]) # Second call: suppression message reported. self._call_error_handler(error_handler, confidence) # The "Suppressing further..." message counts as an additional # message (but not as an addition to the error count). - self.assertEquals(2, self._error_count) - self.assertEquals(3, len(self._error_messages)) - self.assertEquals(self._error_messages[-2], + self.assertEqual(2, self._error_count) + self.assertEqual(3, len(self._error_messages)) + self.assertEqual(self._error_messages[-2], "foo.h(100): message [whitespace/tab] [5]\n") - self.assertEquals(self._error_messages[-1], + self.assertEqual(self._error_messages[-1], "Suppressing further [whitespace/tab] reports " "for this file.\n") # Third call: no report. self._call_error_handler(error_handler, confidence) - self.assertEquals(3, self._error_count) - self.assertEquals(3, len(self._error_messages)) + self.assertEqual(3, self._error_count) + self.assertEqual(3, len(self._error_messages)) def test_line_numbers(self): """Test the line_numbers parameter.""" @@ -177,20 +177,20 @@ class DefaultStyleErrorHandlerTest(unittest.TestCase): # Error on non-modified line: no error. self._call_error_handler(error_handler, confidence, line_number=60) - self.assertEquals(0, self._error_count) - self.assertEquals([], self._error_messages) + self.assertEqual(0, self._error_count) + self.assertEqual([], self._error_messages) # Error on modified line: error. self._call_error_handler(error_handler, confidence, line_number=50) - self.assertEquals(1, self._error_count) - self.assertEquals(self._error_messages, + self.assertEqual(1, self._error_count) + self.assertEqual(self._error_messages, ["foo.h(50): message [whitespace/tab] [5]\n"]) # Error on non-modified line after turning off line filtering: error. error_handler.turn_off_line_filtering() self._call_error_handler(error_handler, confidence, line_number=60) - self.assertEquals(2, self._error_count) - self.assertEquals(self._error_messages, + self.assertEqual(2, self._error_count) + self.assertEqual(self._error_messages, ['foo.h(50): message [whitespace/tab] [5]\n', 'foo.h(60): message [whitespace/tab] [5]\n', 'Suppressing further [whitespace/tab] reports for this file.\n']) diff --git a/Tools/Scripts/webkitpy/style/filereader_unittest.py b/Tools/Scripts/webkitpy/style/filereader_unittest.py index bcf94f33e..d728c463a 100644 --- a/Tools/Scripts/webkitpy/style/filereader_unittest.py +++ b/Tools/Scripts/webkitpy/style/filereader_unittest.py @@ -74,14 +74,14 @@ class TextFileReaderTest(LoggingTestCase): def _assert_file_reader(self, passed_to_processor, file_count): """Assert the state of the file reader.""" - self.assertEquals(passed_to_processor, self._passed_to_processor()) - self.assertEquals(file_count, self._file_reader.file_count) + self.assertEqual(passed_to_processor, self._passed_to_processor()) + self.assertEqual(file_count, self._file_reader.file_count) def test_process_file__does_not_exist(self): try: self._file_reader.process_file('does_not_exist.txt') except SystemExit, err: - self.assertEquals(str(err), '1') + self.assertEqual(str(err), '1') else: self.fail('No Exception raised.') self._assert_file_reader([], 1) @@ -152,4 +152,4 @@ class TextFileReaderTest(LoggingTestCase): def test_count_delete_only_file(self): self._file_reader.count_delete_only_file() delete_only_file_count = self._file_reader.delete_only_file_count - self.assertEquals(delete_only_file_count, 1) + self.assertEqual(delete_only_file_count, 1) diff --git a/Tools/Scripts/webkitpy/style/filter_unittest.py b/Tools/Scripts/webkitpy/style/filter_unittest.py index 7b8a5402a..c20d9981a 100644 --- a/Tools/Scripts/webkitpy/style/filter_unittest.py +++ b/Tools/Scripts/webkitpy/style/filter_unittest.py @@ -30,7 +30,7 @@ from filter import FilterConfiguration # On Testing __eq__() and __ne__(): # -# In the tests below, we deliberately do not use assertEquals() or +# In the tests below, we deliberately do not use assertEqual() or # assertNotEquals() to test __eq__() or __ne__(). We do this to be # very explicit about what we are testing, especially in the case # of assertNotEquals(). @@ -88,17 +88,17 @@ class CategoryFilterTest(unittest.TestCase): """Test __init__ method.""" # Test that the attributes are getting set correctly. filter = CategoryFilter(["+"]) - self.assertEquals(["+"], filter._filter_rules) + self.assertEqual(["+"], filter._filter_rules) def test_init_default_arguments(self): """Test __init__ method default arguments.""" filter = CategoryFilter() - self.assertEquals([], filter._filter_rules) + self.assertEqual([], filter._filter_rules) def test_str(self): """Test __str__ "to string" operator.""" filter = CategoryFilter(["+a", "-b"]) - self.assertEquals(str(filter), "+a,-b") + self.assertEqual(str(filter), "+a,-b") def test_eq(self): """Test __eq__ equality function.""" @@ -162,17 +162,17 @@ class FilterConfigurationTest(unittest.TestCase): config = self._config(base_rules, path_specific, user_rules) - self.assertEquals(base_rules, config._base_rules) - self.assertEquals(path_specific, config._path_specific) - self.assertEquals(user_rules, config._user_rules) + self.assertEqual(base_rules, config._base_rules) + self.assertEqual(path_specific, config._path_specific) + self.assertEqual(user_rules, config._user_rules) def test_default_arguments(self): # Test that the attributes are getting set correctly to the defaults. config = FilterConfiguration() - self.assertEquals([], config._base_rules) - self.assertEquals([], config._path_specific) - self.assertEquals([], config._user_rules) + self.assertEqual([], config._base_rules) + self.assertEqual([], config._path_specific) + self.assertEqual([], config._user_rules) def test_eq(self): """Test __eq__ method.""" diff --git a/Tools/Scripts/webkitpy/style/main_unittest.py b/Tools/Scripts/webkitpy/style/main_unittest.py index 545783300..e0191687a 100644 --- a/Tools/Scripts/webkitpy/style/main_unittest.py +++ b/Tools/Scripts/webkitpy/style/main_unittest.py @@ -43,9 +43,9 @@ class ChangeDirectoryTest(unittest.TestCase): def _assert_result(self, actual_return_value, expected_return_value, expected_log_messages, expected_current_directory): - self.assertEquals(actual_return_value, expected_return_value) + self.assertEqual(actual_return_value, expected_return_value) self._log.assertMessages(expected_log_messages) - self.assertEquals(self.filesystem.getcwd(), expected_current_directory) + self.assertEqual(self.filesystem.getcwd(), expected_current_directory) def test_paths_none(self): paths = self._change_directory(checkout_root=self._checkout_root, paths=None) diff --git a/Tools/Scripts/webkitpy/style/optparser.py b/Tools/Scripts/webkitpy/style/optparser.py index f4e99237b..4b638c055 100644 --- a/Tools/Scripts/webkitpy/style/optparser.py +++ b/Tools/Scripts/webkitpy/style/optparser.py @@ -345,7 +345,7 @@ class ArgumentParser(object): # Override OptionParser's print_help() method so that help output # does not render to the screen while running unit tests. print_help = parser.print_help - parser.print_help = lambda: print_help(file=stderr) + parser.print_help = lambda file=stderr: print_help(file=file) return parser diff --git a/Tools/Scripts/webkitpy/style/optparser_unittest.py b/Tools/Scripts/webkitpy/style/optparser_unittest.py index a6b64da42..979b31d1a 100644 --- a/Tools/Scripts/webkitpy/style/optparser_unittest.py +++ b/Tools/Scripts/webkitpy/style/optparser_unittest.py @@ -49,14 +49,14 @@ class ArgumentPrinterTest(unittest.TestCase): def test_to_flag_string(self): options = self._create_options('vs7', 5, ['+foo', '-bar'], 'git') - self.assertEquals('--filter=+foo,-bar --git-commit=git ' + self.assertEqual('--filter=+foo,-bar --git-commit=git ' '--min-confidence=5 --output=vs7', self._printer.to_flag_string(options)) # This is to check that --filter and --git-commit do not # show up when not user-specified. options = self._create_options() - self.assertEquals('--min-confidence=3 --output=emacs', + self.assertEqual('--min-confidence=3 --output=emacs', self._printer.to_flag_string(options)) @@ -142,53 +142,53 @@ class ArgumentParserTest(LoggingTestCase): (files, options) = parse([]) - self.assertEquals(files, []) + self.assertEqual(files, []) - self.assertEquals(options.filter_rules, []) - self.assertEquals(options.git_commit, None) - self.assertEquals(options.diff_files, False) - self.assertEquals(options.is_verbose, False) - self.assertEquals(options.min_confidence, 3) - self.assertEquals(options.output_format, 'vs7') + self.assertEqual(options.filter_rules, []) + self.assertEqual(options.git_commit, None) + self.assertEqual(options.diff_files, False) + self.assertEqual(options.is_verbose, False) + self.assertEqual(options.min_confidence, 3) + self.assertEqual(options.output_format, 'vs7') def test_parse_explicit_arguments(self): parse = self._parse # Pass non-default explicit values. (files, options) = parse(['--min-confidence=4']) - self.assertEquals(options.min_confidence, 4) + self.assertEqual(options.min_confidence, 4) (files, options) = parse(['--output=emacs']) - self.assertEquals(options.output_format, 'emacs') + self.assertEqual(options.output_format, 'emacs') (files, options) = parse(['-g', 'commit']) - self.assertEquals(options.git_commit, 'commit') + self.assertEqual(options.git_commit, 'commit') (files, options) = parse(['--git-commit=commit']) - self.assertEquals(options.git_commit, 'commit') + self.assertEqual(options.git_commit, 'commit') (files, options) = parse(['--git-diff=commit']) - self.assertEquals(options.git_commit, 'commit') + self.assertEqual(options.git_commit, 'commit') (files, options) = parse(['--verbose']) - self.assertEquals(options.is_verbose, True) + self.assertEqual(options.is_verbose, True) (files, options) = parse(['--diff-files', 'file.txt']) - self.assertEquals(options.diff_files, True) + self.assertEqual(options.diff_files, True) # Pass user_rules. (files, options) = parse(['--filter=+build,-whitespace']) - self.assertEquals(options.filter_rules, + self.assertEqual(options.filter_rules, ["+build", "-whitespace"]) # Pass spurious white space in user rules. (files, options) = parse(['--filter=+build, -whitespace']) - self.assertEquals(options.filter_rules, + self.assertEqual(options.filter_rules, ["+build", "-whitespace"]) def test_parse_files(self): parse = self._parse (files, options) = parse(['foo.cpp']) - self.assertEquals(files, ['foo.cpp']) + self.assertEqual(files, ['foo.cpp']) # Pass multiple files. (files, options) = parse(['--output=emacs', 'foo.cpp', 'bar.cpp']) - self.assertEquals(files, ['foo.cpp', 'bar.cpp']) + self.assertEqual(files, ['foo.cpp', 'bar.cpp']) class CommandOptionValuesTest(unittest.TestCase): @@ -199,11 +199,11 @@ class CommandOptionValuesTest(unittest.TestCase): """Test __init__ constructor.""" # Check default parameters. options = ProcessorOptions() - self.assertEquals(options.filter_rules, []) - self.assertEquals(options.git_commit, None) - self.assertEquals(options.is_verbose, False) - self.assertEquals(options.min_confidence, 1) - self.assertEquals(options.output_format, "emacs") + self.assertEqual(options.filter_rules, []) + self.assertEqual(options.git_commit, None) + self.assertEqual(options.is_verbose, False) + self.assertEqual(options.min_confidence, 1) + self.assertEqual(options.output_format, "emacs") # Check argument validation. self.assertRaises(ValueError, ProcessorOptions, output_format="bad") @@ -220,11 +220,11 @@ class CommandOptionValuesTest(unittest.TestCase): is_verbose=True, min_confidence=3, output_format="vs7") - self.assertEquals(options.filter_rules, ["+"]) - self.assertEquals(options.git_commit, "commit") - self.assertEquals(options.is_verbose, True) - self.assertEquals(options.min_confidence, 3) - self.assertEquals(options.output_format, "vs7") + self.assertEqual(options.filter_rules, ["+"]) + self.assertEqual(options.git_commit, "commit") + self.assertEqual(options.is_verbose, True) + self.assertEqual(options.min_confidence, 3) + self.assertEqual(options.output_format, "vs7") def test_eq(self): """Test __eq__ equality function.""" diff --git a/Tools/Scripts/webkitpy/style/patchreader_unittest.py b/Tools/Scripts/webkitpy/style/patchreader_unittest.py index eb26d4761..983b609e4 100644 --- a/Tools/Scripts/webkitpy/style/patchreader_unittest.py +++ b/Tools/Scripts/webkitpy/style/patchreader_unittest.py @@ -64,9 +64,9 @@ class PatchReaderTest(unittest.TestCase): self._patch_checker.check(patch_string) def _assert_checked(self, passed_to_process_file, delete_only_file_count): - self.assertEquals(self._file_reader.passed_to_process_file, + self.assertEqual(self._file_reader.passed_to_process_file, passed_to_process_file) - self.assertEquals(self._file_reader.delete_only_file_count, + self.assertEqual(self._file_reader.delete_only_file_count, delete_only_file_count) def test_check_patch(self): diff --git a/Tools/Scripts/webkitpy/test/finder_unittest.py b/Tools/Scripts/webkitpy/test/finder_unittest.py index 5c808a17e..694b3884a 100644 --- a/Tools/Scripts/webkitpy/test/finder_unittest.py +++ b/Tools/Scripts/webkitpy/test/finder_unittest.py @@ -58,7 +58,7 @@ class FinderTest(unittest.TestCase): handler.level = self.log_levels.pop(0) def test_additional_system_paths(self): - self.assertEquals(self.finder.additional_paths(['/usr']), + self.assertEqual(self.finder.additional_paths(['/usr']), ['/foo', '/foo2']) def test_is_module(self): @@ -70,9 +70,9 @@ class FinderTest(unittest.TestCase): self.assertFalse(self.finder.is_module('baz')) def test_to_module(self): - self.assertEquals(self.finder.to_module('/foo/test.py'), 'test') - self.assertEquals(self.finder.to_module('/foo/bar/test.py'), 'bar.test') - self.assertEquals(self.finder.to_module('/foo/bar/pytest.py'), 'bar.pytest') + self.assertEqual(self.finder.to_module('/foo/test.py'), 'test') + self.assertEqual(self.finder.to_module('/foo/bar/test.py'), 'bar.test') + self.assertEqual(self.finder.to_module('/foo/bar/pytest.py'), 'bar.pytest') def test_clean(self): self.assertTrue(self.fs.exists('/foo2/bar2/missing.pyc')) @@ -80,7 +80,7 @@ class FinderTest(unittest.TestCase): self.assertFalse(self.fs.exists('/foo2/bar2/missing.pyc')) def check_names(self, names, expected_names, find_all=True): - self.assertEquals(self.finder.find_names(names, find_all), expected_names) + self.assertEqual(self.finder.find_names(names, find_all), expected_names) def test_default_names(self): self.check_names([], ['bar.baz_unittest', 'bar2.baz2_integrationtest'], find_all=True) diff --git a/Tools/Scripts/webkitpy/test/main.py b/Tools/Scripts/webkitpy/test/main.py index e639a4578..d8f997805 100644 --- a/Tools/Scripts/webkitpy/test/main.py +++ b/Tools/Scripts/webkitpy/test/main.py @@ -135,6 +135,9 @@ class Tester(object): self._options.child_processes = 1 if self._options.coverage: + _log.warning("Checking code coverage, so running things serially") + self._options.child_processes = 1 + import webkitpy.thirdparty.autoinstalled.coverage as coverage cov = coverage.coverage() cov.start() diff --git a/Tools/Scripts/webkitpy/test/main_unittest.py b/Tools/Scripts/webkitpy/test/main_unittest.py index 4fa6ef384..031abd65b 100644 --- a/Tools/Scripts/webkitpy/test/main_unittest.py +++ b/Tools/Scripts/webkitpy/test/main_unittest.py @@ -81,25 +81,25 @@ class TesterTest(unittest.TestCase): def test_individual_names_are_not_run_twice(self): args = [STUBS_CLASS + '.test_empty'] parallel_tests, serial_tests = self._find_test_names(args) - self.assertEquals(parallel_tests, args) - self.assertEquals(serial_tests, []) + self.assertEqual(parallel_tests, args) + self.assertEqual(serial_tests, []) def test_integration_tests_are_not_found_by_default(self): parallel_tests, serial_tests = self._find_test_names([STUBS_CLASS]) - self.assertEquals(parallel_tests, [ + self.assertEqual(parallel_tests, [ STUBS_CLASS + '.test_empty', ]) - self.assertEquals(serial_tests, [ + self.assertEqual(serial_tests, [ STUBS_CLASS + '.serial_test_empty', ]) def test_integration_tests_are_found(self): parallel_tests, serial_tests = self._find_test_names(['--integration-tests', STUBS_CLASS]) - self.assertEquals(parallel_tests, [ + self.assertEqual(parallel_tests, [ STUBS_CLASS + '.integration_test_empty', STUBS_CLASS + '.test_empty', ]) - self.assertEquals(serial_tests, [ + self.assertEqual(serial_tests, [ STUBS_CLASS + '.serial_integration_test_empty', STUBS_CLASS + '.serial_test_empty', ]) @@ -113,5 +113,5 @@ class TesterTest(unittest.TestCase): stdout=executive.PIPE, stderr=executive.PIPE) out, _ = proc.communicate() retcode = proc.returncode - self.assertEquals(retcode, 0) + self.assertEqual(retcode, 0) self.assertTrue('Cover' in out) diff --git a/Tools/Scripts/webkitpy/test/runner_unittest.py b/Tools/Scripts/webkitpy/test/runner_unittest.py index 8fe1b0633..e5be1921c 100644 --- a/Tools/Scripts/webkitpy/test/runner_unittest.py +++ b/Tools/Scripts/webkitpy/test/runner_unittest.py @@ -92,9 +92,9 @@ class RunnerTest(unittest.TestCase): ('test3 (Foo)', 'E', 'test3\nerred')) runner = Runner(Printer(stream, options), loader) runner.run(['Foo.test1', 'Foo.test2', 'Foo.test3'], 1) - self.assertEquals(runner.tests_run, 3) - self.assertEquals(len(runner.failures), 1) - self.assertEquals(len(runner.errors), 1) + self.assertEqual(runner.tests_run, 3) + self.assertEqual(len(runner.failures), 1) + self.assertEqual(len(runner.errors), 1) if __name__ == '__main__': diff --git a/Tools/Scripts/webkitpy/thirdparty/__init__.py b/Tools/Scripts/webkitpy/thirdparty/__init__.py index 74ea5f601..ee5891122 100644 --- a/Tools/Scripts/webkitpy/thirdparty/__init__.py +++ b/Tools/Scripts/webkitpy/thirdparty/__init__.py @@ -105,7 +105,9 @@ class AutoinstallImportHook(object): def _install_pylint(self): self._ensure_autoinstalled_dir_is_in_sys_path() did_install_something = False - if not self._fs.exists(self._fs.join(_AUTOINSTALLED_DIR, "pylint")): + if (not self._fs.exists(self._fs.join(_AUTOINSTALLED_DIR, "pylint")) or + not self._fs.exists(self._fs.join(_AUTOINSTALLED_DIR, "logilab/astng")) or + not self._fs.exists(self._fs.join(_AUTOINSTALLED_DIR, "logilab/common"))): installer = AutoInstaller(target_dir=_AUTOINSTALLED_DIR) did_install_something = installer.install("http://pypi.python.org/packages/source/l/logilab-common/logilab-common-0.58.1.tar.gz#md5=77298ab2d8bb8b4af9219791e7cee8ce", url_subpath="logilab-common-0.58.1", target_name="logilab/common") did_install_something |= installer.install("http://pypi.python.org/packages/source/l/logilab-astng/logilab-astng-0.24.1.tar.gz#md5=ddaf66e4d85714d9c47a46d4bed406de", url_subpath="logilab-astng-0.24.1", target_name="logilab/astng") diff --git a/Tools/Scripts/webkitpy/tool/bot/commitqueuetask_unittest.py b/Tools/Scripts/webkitpy/tool/bot/commitqueuetask_unittest.py index 8b3341623..2958c6cc1 100644 --- a/Tools/Scripts/webkitpy/tool/bot/commitqueuetask_unittest.py +++ b/Tools/Scripts/webkitpy/tool/bot/commitqueuetask_unittest.py @@ -564,7 +564,7 @@ command_failed: failure_message='Unable to land patch' script_error='MOCK land f return ExpectedFailures() task = CommitQueueTask(MockDelegate(), patch) - self.assertEquals(task.validate(), is_valid) + self.assertEqual(task.validate(), is_valid) def _mock_patch(self, attachment_dict={}, bug_dict={'bug_status': 'NEW'}, committer="fake"): bug = bugzilla.Bug(bug_dict, None) diff --git a/Tools/Scripts/webkitpy/tool/bot/expectedfailures_unittest.py b/Tools/Scripts/webkitpy/tool/bot/expectedfailures_unittest.py index 4c1c3d929..3cee3f059 100644 --- a/Tools/Scripts/webkitpy/tool/bot/expectedfailures_unittest.py +++ b/Tools/Scripts/webkitpy/tool/bot/expectedfailures_unittest.py @@ -45,7 +45,7 @@ class MockResults(object): class ExpectedFailuresTest(unittest.TestCase): def _assert_can_trust(self, results, can_trust): - self.assertEquals(ExpectedFailures._should_trust(results), can_trust) + self.assertEqual(ExpectedFailures._should_trust(results), can_trust) def test_can_trust_results(self): self._assert_can_trust(None, False) @@ -77,19 +77,19 @@ class ExpectedFailuresTest(unittest.TestCase): def test_unexpected_failures_observed(self): failures = ExpectedFailures() failures.update(MockResults(['foo.html'])) - self.assertEquals(failures.unexpected_failures_observed(MockResults(['foo.html', 'bar.html'])), set(['bar.html'])) - self.assertEquals(failures.unexpected_failures_observed(MockResults(['baz.html'])), set(['baz.html'])) + self.assertEqual(failures.unexpected_failures_observed(MockResults(['foo.html', 'bar.html'])), set(['bar.html'])) + self.assertEqual(failures.unexpected_failures_observed(MockResults(['baz.html'])), set(['baz.html'])) unbounded_results = MockResults(['baz.html', 'qux.html', 'taco.html'], failure_limit=3) - self.assertEquals(failures.unexpected_failures_observed(unbounded_results), set(['baz.html', 'qux.html', 'taco.html'])) + self.assertEqual(failures.unexpected_failures_observed(unbounded_results), set(['baz.html', 'qux.html', 'taco.html'])) unbounded_results_with_existing_failure = MockResults(['foo.html', 'baz.html', 'qux.html', 'taco.html'], failure_limit=4) - self.assertEquals(failures.unexpected_failures_observed(unbounded_results_with_existing_failure), set(['baz.html', 'qux.html', 'taco.html'])) + self.assertEqual(failures.unexpected_failures_observed(unbounded_results_with_existing_failure), set(['baz.html', 'qux.html', 'taco.html'])) def test_unexpected_failures_observed_when_tree_is_hosed(self): failures = ExpectedFailures() failures.update(MockResults(['foo.html', 'banana.html'], failure_limit=2)) - self.assertEquals(failures.unexpected_failures_observed(MockResults(['foo.html', 'bar.html'])), None) - self.assertEquals(failures.unexpected_failures_observed(MockResults(['baz.html'])), None) + self.assertEqual(failures.unexpected_failures_observed(MockResults(['foo.html', 'bar.html'])), None) + self.assertEqual(failures.unexpected_failures_observed(MockResults(['baz.html'])), None) unbounded_results = MockResults(['baz.html', 'qux.html', 'taco.html'], failure_limit=3) - self.assertEquals(failures.unexpected_failures_observed(unbounded_results), None) + self.assertEqual(failures.unexpected_failures_observed(unbounded_results), None) unbounded_results_with_existing_failure = MockResults(['foo.html', 'baz.html', 'qux.html', 'taco.html'], failure_limit=4) - self.assertEquals(failures.unexpected_failures_observed(unbounded_results_with_existing_failure), None) + self.assertEqual(failures.unexpected_failures_observed(unbounded_results_with_existing_failure), None) diff --git a/Tools/Scripts/webkitpy/tool/bot/feeders_unittest.py b/Tools/Scripts/webkitpy/tool/bot/feeders_unittest.py index dff48ad8b..060a5c85b 100644 --- a/Tools/Scripts/webkitpy/tool/bot/feeders_unittest.py +++ b/Tools/Scripts/webkitpy/tool/bot/feeders_unittest.py @@ -77,4 +77,4 @@ Feeding commit-queue items [10005, 10000] feeder = CommitQueueFeeder(MockTool()) patches = [MockPatch(1, None), MockPatch(2, '-'), MockPatch(3, "+")] - self.assertEquals([patch.id for patch in feeder._patches_with_acceptable_review_flag(patches)], [1, 3]) + self.assertEqual([patch.id for patch in feeder._patches_with_acceptable_review_flag(patches)], [1, 3]) diff --git a/Tools/Scripts/webkitpy/tool/bot/irc_command_unittest.py b/Tools/Scripts/webkitpy/tool/bot/irc_command_unittest.py index 4dec669fd..4abee6678 100644 --- a/Tools/Scripts/webkitpy/tool/bot/irc_command_unittest.py +++ b/Tools/Scripts/webkitpy/tool/bot/irc_command_unittest.py @@ -37,30 +37,30 @@ from webkitpy.common.system.executive_mock import MockExecutive class IRCCommandTest(unittest.TestCase): def test_whois(self): whois = Whois() - self.assertEquals("tom: Usage: whois SEARCH_STRING", + self.assertEqual("tom: Usage: whois SEARCH_STRING", whois.execute("tom", [], None, None)) - self.assertEquals("tom: Usage: whois SEARCH_STRING", + self.assertEqual("tom: Usage: whois SEARCH_STRING", whois.execute("tom", ["Adam", "Barth"], None, None)) - self.assertEquals("tom: Sorry, I don't know any contributors matching 'unknown@example.com'.", + self.assertEqual("tom: Sorry, I don't know any contributors matching 'unknown@example.com'.", whois.execute("tom", ["unknown@example.com"], None, None)) - self.assertEquals("tom: tonyg@chromium.org is tonyg-cr. Why do you ask?", + self.assertEqual("tom: tonyg@chromium.org is tonyg-cr. Why do you ask?", whois.execute("tom", ["tonyg@chromium.org"], None, None)) - self.assertEquals("tom: TonyG@Chromium.org is tonyg-cr. Why do you ask?", + self.assertEqual("tom: TonyG@Chromium.org is tonyg-cr. Why do you ask?", whois.execute("tom", ["TonyG@Chromium.org"], None, None)) - self.assertEquals("tom: rniwa is rniwa (rniwa@webkit.org). Why do you ask?", + self.assertEqual("tom: rniwa is rniwa (rniwa@webkit.org). Why do you ask?", whois.execute("tom", ["rniwa"], None, None)) - self.assertEquals("tom: lopez is xan (xan.lopez@gmail.com, xan@gnome.org, xan@webkit.org, xlopez@igalia.com). Why do you ask?", + self.assertEqual("tom: lopez is xan (xan.lopez@gmail.com, xan@gnome.org, xan@webkit.org, xlopez@igalia.com). Why do you ask?", whois.execute("tom", ["lopez"], None, None)) - self.assertEquals('tom: "Vicki Murley" <vicki@apple.com> hasn\'t told me their nick. Boo hoo :-(', + self.assertEqual('tom: "Vicki Murley" <vicki@apple.com> hasn\'t told me their nick. Boo hoo :-(', whois.execute("tom", ["vicki@apple.com"], None, None)) - self.assertEquals('tom: I\'m not sure who you mean? gavinp or gbarra could be \'Gavin\'.', + self.assertEqual('tom: I\'m not sure who you mean? gavinp or gbarra could be \'Gavin\'.', whois.execute("tom", ["Gavin"], None, None)) - self.assertEquals('tom: More than 5 contributors match \'david\', could you be more specific?', + self.assertEqual('tom: More than 5 contributors match \'david\', could you be more specific?', whois.execute("tom", ["david"], None, None)) def test_create_bug(self): create_bug = CreateBug() - self.assertEquals("tom: Usage: create-bug BUG_TITLE", + self.assertEqual("tom: Usage: create-bug BUG_TITLE", create_bug.execute("tom", [], None, None)) example_args = ["sherrif-bot", "should", "have", "a", "create-bug", "command"] @@ -68,19 +68,19 @@ class IRCCommandTest(unittest.TestCase): # MockBugzilla has a create_bug, but it logs to stderr, this avoids any logging. tool.bugs.create_bug = lambda a, b, cc=None, assignee=None: 50004 - self.assertEquals("tom: Created bug: http://example.com/50004", + self.assertEqual("tom: Created bug: http://example.com/50004", create_bug.execute("tom", example_args, tool, None)) def mock_create_bug(title, description, cc=None, assignee=None): raise Exception("Exception from bugzilla!") tool.bugs.create_bug = mock_create_bug - self.assertEquals("tom: Failed to create bug:\nException from bugzilla!", + self.assertEqual("tom: Failed to create bug:\nException from bugzilla!", create_bug.execute("tom", example_args, tool, None)) def test_roll_chromium_deps(self): roll = RollChromiumDEPS() - self.assertEquals(None, roll._parse_args([])) - self.assertEquals("1234", roll._parse_args(["1234"])) + self.assertEqual(None, roll._parse_args([])) + self.assertEqual("1234", roll._parse_args(["1234"])) def test_rollout_updates_working_copy(self): rollout = Rollout() @@ -91,27 +91,27 @@ class IRCCommandTest(unittest.TestCase): def test_rollout(self): rollout = Rollout() - self.assertEquals(([1234], "testing foo"), + self.assertEqual(([1234], "testing foo"), rollout._parse_args(["1234", "testing", "foo"])) - self.assertEquals(([554], "testing foo"), + self.assertEqual(([554], "testing foo"), rollout._parse_args(["r554", "testing", "foo"])) - self.assertEquals(([556, 792], "testing foo"), + self.assertEqual(([556, 792], "testing foo"), rollout._parse_args(["r556", "792", "testing", "foo"])) - self.assertEquals(([128, 256], "testing foo"), + self.assertEqual(([128, 256], "testing foo"), rollout._parse_args(["r128,r256", "testing", "foo"])) - self.assertEquals(([512, 1024, 2048], "testing foo"), + self.assertEqual(([512, 1024, 2048], "testing foo"), rollout._parse_args(["512,", "1024,2048", "testing", "foo"])) # Test invalid argument parsing: - self.assertEquals((None, None), rollout._parse_args([])) - self.assertEquals((None, None), rollout._parse_args(["--bar", "1234"])) + self.assertEqual((None, None), rollout._parse_args([])) + self.assertEqual((None, None), rollout._parse_args(["--bar", "1234"])) # Invalid arguments result in the USAGE message. - self.assertEquals("tom: Usage: rollout SVN_REVISION [SVN_REVISIONS] REASON", + self.assertEqual("tom: Usage: rollout SVN_REVISION [SVN_REVISIONS] REASON", rollout.execute("tom", [], None, None)) # FIXME: We need a better way to test IRCCommands which call tool.irc().post() diff --git a/Tools/Scripts/webkitpy/tool/bot/layouttestresultsreader_unittest.py b/Tools/Scripts/webkitpy/tool/bot/layouttestresultsreader_unittest.py index 0eb348297..96e2e4eef 100644 --- a/Tools/Scripts/webkitpy/tool/bot/layouttestresultsreader_unittest.py +++ b/Tools/Scripts/webkitpy/tool/bot/layouttestresultsreader_unittest.py @@ -47,7 +47,7 @@ class LayoutTestResultsReaderTest(unittest.TestCase): self.assertRaises(IOError, tool.filesystem.read_text_file, layout_tests_results_path) self.assertRaises(IOError, tool.filesystem.read_text_file, unit_tests_results_path) # layout_test_results shouldn't raise even if the results.html file is missing. - self.assertEquals(reader.results(), None) + self.assertEqual(reader.results(), None) def test_create_unit_test_results(self): tool = MockTool() @@ -62,7 +62,7 @@ class LayoutTestResultsReaderTest(unittest.TestCase): </testsuite> </testsuites>""" tool.filesystem = MockFileSystem({unit_tests_results_path: no_failures_xml}) - self.assertEquals(reader._create_unit_test_results(), []) + self.assertEqual(reader._create_unit_test_results(), []) def test_missing_unit_test_results_path(self): tool = MockTool() @@ -71,19 +71,19 @@ class LayoutTestResultsReaderTest(unittest.TestCase): reader._create_layout_test_results = lambda: LayoutTestResults([]) # layout_test_results shouldn't raise even if the unit tests xml file is missing. self.assertNotEquals(reader.results(), None) - self.assertEquals(reader.results().failing_tests(), []) + self.assertEqual(reader.results().failing_tests(), []) def test_layout_test_results(self): reader = LayoutTestResultsReader(MockTool(), "/var/logs") reader._read_file_contents = lambda path: None - self.assertEquals(reader.results(), None) + self.assertEqual(reader.results(), None) reader._read_file_contents = lambda path: "" - self.assertEquals(reader.results(), None) + self.assertEqual(reader.results(), None) reader._create_layout_test_results = lambda: LayoutTestResults([]) results = reader.results() self.assertNotEquals(results, None) - self.assertEquals(results.failure_limit_count(), 30) # This value matches RunTests.NON_INTERACTIVE_FAILURE_LIMIT_COUNT + self.assertEqual(results.failure_limit_count(), 30) # This value matches RunTests.NON_INTERACTIVE_FAILURE_LIMIT_COUNT def test_archive_last_layout_test_results(self): tool = MockTool() diff --git a/Tools/Scripts/webkitpy/tool/bot/queueengine_unittest.py b/Tools/Scripts/webkitpy/tool/bot/queueengine_unittest.py index f959ee149..26789ef05 100644 --- a/Tools/Scripts/webkitpy/tool/bot/queueengine_unittest.py +++ b/Tools/Scripts/webkitpy/tool/bot/queueengine_unittest.py @@ -83,12 +83,12 @@ class LoggingDelegate(QueueEngineDelegate): def process_work_item(self, work_item): self.record("process_work_item") - self._test.assertEquals(work_item, "work_item") + self._test.assertEqual(work_item, "work_item") return True def handle_unexpected_error(self, work_item, message): self.record("handle_unexpected_error") - self._test.assertEquals(work_item, "work_item") + self._test.assertEqual(work_item, "work_item") def stop_work_queue(self, message): self.record("stop_work_queue") @@ -120,8 +120,8 @@ class QueueEngineTest(unittest.TestCase): def test_trivial(self): delegate = LoggingDelegate(self) self._run_engine(delegate) - self.assertEquals(delegate.stop_message, "Delegate terminated queue.") - self.assertEquals(delegate._callbacks, LoggingDelegate.expected_callbacks) + self.assertEqual(delegate.stop_message, "Delegate terminated queue.") + self.assertEqual(delegate._callbacks, LoggingDelegate.expected_callbacks) self.assertTrue(os.path.exists(os.path.join(self.temp_dir, "queue_log_path"))) self.assertTrue(os.path.exists(os.path.join(self.temp_dir, "work_log_path", "work_item.log"))) @@ -133,12 +133,12 @@ class QueueEngineTest(unittest.TestCase): # The unexpected error should be handled right after process_work_item starts # but before any other callback. Otherwise callbacks should be normal. expected_callbacks.insert(work_item_index + 1, 'handle_unexpected_error') - self.assertEquals(delegate._callbacks, expected_callbacks) + self.assertEqual(delegate._callbacks, expected_callbacks) def test_handled_error(self): delegate = RaisingDelegate(self, ScriptError(exit_code=QueueEngine.handled_error_code)) self._run_engine(delegate) - self.assertEquals(delegate._callbacks, LoggingDelegate.expected_callbacks) + self.assertEqual(delegate._callbacks, LoggingDelegate.expected_callbacks) def _run_engine(self, delegate, engine=None, termination_message=None): if not engine: @@ -158,8 +158,8 @@ class QueueEngineTest(unittest.TestCase): delegate = RaisingDelegate(self, exception) self._run_engine(delegate, termination_message=termination_message) - self.assertEquals(delegate._callbacks, expected_callbacks) - self.assertEquals(delegate.stop_message, termination_message) + self.assertEqual(delegate._callbacks, expected_callbacks) + self.assertEqual(delegate.stop_message, termination_message) def test_terminating_error(self): self._test_terminating_queue(KeyboardInterrupt(), "User terminated queue.") diff --git a/Tools/Scripts/webkitpy/tool/commands/__init__.py b/Tools/Scripts/webkitpy/tool/commands/__init__.py index 4e8eb62e1..45711815e 100644 --- a/Tools/Scripts/webkitpy/tool/commands/__init__.py +++ b/Tools/Scripts/webkitpy/tool/commands/__init__.py @@ -8,7 +8,6 @@ from webkitpy.tool.commands.bugsearch import BugSearch from webkitpy.tool.commands.chromechannels import ChromeChannels from webkitpy.tool.commands.download import * from webkitpy.tool.commands.earlywarningsystem import * -from webkitpy.tool.commands.expectations import OptimizeExpectations from webkitpy.tool.commands.findusers import FindUsers from webkitpy.tool.commands.gardenomatic import GardenOMatic from webkitpy.tool.commands.openbugs import OpenBugs diff --git a/Tools/Scripts/webkitpy/tool/commands/abstractlocalservercommand.py b/Tools/Scripts/webkitpy/tool/commands/abstractlocalservercommand.py index 6c54da25e..0a7788c11 100644 --- a/Tools/Scripts/webkitpy/tool/commands/abstractlocalservercommand.py +++ b/Tools/Scripts/webkitpy/tool/commands/abstractlocalservercommand.py @@ -53,5 +53,5 @@ class AbstractLocalServerCommand(AbstractDeclarativeCommand): # FIXME: This seems racy. threading.Timer(0.1, lambda: self._tool.user.open_url(server_url)).start() - httpd = self.server(httpd_port=options.httpd_port, config=config) + httpd = self.server(httpd_port=options.httpd_port, config=config) # pylint: disable-msg=E1102 httpd.serve_forever() diff --git a/Tools/Scripts/webkitpy/tool/commands/download.py b/Tools/Scripts/webkitpy/tool/commands/download.py index 1f73d1884..b3ee1239c 100644 --- a/Tools/Scripts/webkitpy/tool/commands/download.py +++ b/Tools/Scripts/webkitpy/tool/commands/download.py @@ -4,7 +4,7 @@ # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: -# +# # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above @@ -14,7 +14,7 @@ # * Neither the name of Google Inc. nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. -# +# # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -146,8 +146,10 @@ class AbstractPatchProcessingCommand(AbstractDeclarativeCommand): # Subclasses must implement the methods below. We don't declare them here # because we want to be able to implement them with mix-ins. # + # pylint: disable-msg=E1101 # def _fetch_list_of_patches_to_process(self, options, args, tool): # def _prepare_to_process(self, options, args, tool): + # def _process_patch(self, options, args, tool): @staticmethod def _collect_patches_by_bug(patches): diff --git a/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem.py b/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem.py index b7d5df31e..3ebdf390a 100644 --- a/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem.py +++ b/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem.py @@ -45,6 +45,9 @@ class AbstractEarlyWarningSystem(AbstractReviewQueue, EarlyWarningSystemTaskDele # FIXME: Switch _default_run_tests from opt-in to opt-out once more bots are ready to run tests. _default_run_tests = False + # Subclasses must override. + port_name = None + def __init__(self): options = [make_option("--run-tests", action="store_true", dest="run_tests", default=self._default_run_tests, help="Run the Layout tests for each patch")] AbstractReviewQueue.__init__(self, options=options) @@ -139,7 +142,6 @@ class GtkEWS(AbstractEarlyWarningSystem): name = "gtk-ews" port_name = "gtk" watchers = AbstractEarlyWarningSystem.watchers + [ - "gns@gnome.org", "xan.lopez@gmail.com", ] diff --git a/Tools/Scripts/webkitpy/tool/commands/expectations.py b/Tools/Scripts/webkitpy/tool/commands/expectations.py deleted file mode 100644 index 0e1050ba7..000000000 --- a/Tools/Scripts/webkitpy/tool/commands/expectations.py +++ /dev/null @@ -1,44 +0,0 @@ -# Copyright (c) 2011 Google Inc. All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: -# -# * Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# * Redistributions in binary form must reproduce the above -# copyright notice, this list of conditions and the following disclaimer -# in the documentation and/or other materials provided with the -# distribution. -# * Neither the name of Google Inc. nor the names of its -# contributors may be used to endorse or promote products derived from -# this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -from webkitpy.layout_tests.models.test_configuration import TestConfigurationConverter -from webkitpy.layout_tests.models.test_expectations import TestExpectationParser -from webkitpy.layout_tests.models.test_expectations import TestExpectations -from webkitpy.tool.multicommandtool import AbstractDeclarativeCommand - - -class OptimizeExpectations(AbstractDeclarativeCommand): - name = "optimize-expectations" - help_text = "Fixes simple style issues in test_expectations file. (Currently works only for chromium port.)" - - def execute(self, options, args, tool): - port = tool.port_factory.get("chromium-win-win7") # FIXME: This should be selectable. - parser = TestExpectationParser(port, [], allow_rebaseline_modifier=False) - expectation_lines = parser.parse(port.test_expectations()) - converter = TestConfigurationConverter(port.all_test_configurations(), port.configuration_specifier_macros()) - tool.filesystem.write_text_file(port.path_to_test_expectations_file(), TestExpectations.list_to_string(expectation_lines, converter)) diff --git a/Tools/Scripts/webkitpy/tool/commands/gardenomatic.py b/Tools/Scripts/webkitpy/tool/commands/gardenomatic.py index 6cb1519ef..c87c1a265 100644 --- a/Tools/Scripts/webkitpy/tool/commands/gardenomatic.py +++ b/Tools/Scripts/webkitpy/tool/commands/gardenomatic.py @@ -32,7 +32,7 @@ class GardenOMatic(AbstractRebaseliningCommand): help_text = "Command for gardening the WebKit tree." def __init__(self): - return super(AbstractRebaseliningCommand, self).__init__(options=(self.platform_options + [ + super(GardenOMatic, self).__init__(options=(self.platform_options + [ self.move_overwritten_baselines_option, self.results_directory_option, self.no_optimize_option, diff --git a/Tools/Scripts/webkitpy/tool/commands/openbugs_unittest.py b/Tools/Scripts/webkitpy/tool/commands/openbugs_unittest.py index 40a6e1b2e..06dac1fd6 100644 --- a/Tools/Scripts/webkitpy/tool/commands/openbugs_unittest.py +++ b/Tools/Scripts/webkitpy/tool/commands/openbugs_unittest.py @@ -43,7 +43,7 @@ class OpenBugsTest(CommandsTest): def test_find_bugs_in_string(self): openbugs = OpenBugs() for expectation in self.find_bugs_in_string_expectations: - self.assertEquals(openbugs._find_bugs_in_string(expectation[0]), expectation[1]) + self.assertEqual(openbugs._find_bugs_in_string(expectation[0]), expectation[1]) def test_args_parsing(self): expected_stderr = "2 bugs found in input.\nMOCK: user.open_url: http://example.com/12345\nMOCK: user.open_url: http://example.com/23456\n" diff --git a/Tools/Scripts/webkitpy/tool/commands/queries.py b/Tools/Scripts/webkitpy/tool/commands/queries.py index b7e4a8588..93e0df3d3 100644 --- a/Tools/Scripts/webkitpy/tool/commands/queries.py +++ b/Tools/Scripts/webkitpy/tool/commands/queries.py @@ -440,13 +440,15 @@ class PrintExpectations(AbstractDeclarativeCommand): help='Print a CSV-style report that includes the port name, modifiers, tests, and expectations'), make_option('-f', '--full', action='store_true', default=False, help='Print a full TestExpectations-style line for every match'), + make_option('--paths', action='store_true', default=False, + help='display the paths for all applicable expectation files'), ] + platform_options(use_globs=True) AbstractDeclarativeCommand.__init__(self, options=options) self._expectation_models = {} def execute(self, options, args, tool): - if not args and not options.all: + if not options.paths and not args and not options.all: print "You must either specify one or more test paths or --all." return @@ -465,6 +467,15 @@ class PrintExpectations(AbstractDeclarativeCommand): default_port = tool.port_factory.get(options=options) port_names = [default_port.name()] + if options.paths: + files = default_port.expectations_files() + layout_tests_dir = default_port.layout_tests_dir() + for file in files: + if file.startswith(layout_tests_dir): + file = file.replace(layout_tests_dir, 'LayoutTests') + print file + return + tests = default_port.tests(args) for port_name in port_names: model = self._model(options, port_name, tests) diff --git a/Tools/Scripts/webkitpy/tool/commands/queries_unittest.py b/Tools/Scripts/webkitpy/tool/commands/queries_unittest.py index 79bf1ca9d..ef1e0b387 100644 --- a/Tools/Scripts/webkitpy/tool/commands/queries_unittest.py +++ b/Tools/Scripts/webkitpy/tool/commands/queries_unittest.py @@ -150,18 +150,18 @@ class FailureReasonTest(unittest.TestCase): command = FailureReason() command.bind_to_tool(tool) # This is an artificial example, mostly to test the CommitInfo lookup failure case. - self.assertEquals(command._blame_line_for_revision(0), "FAILED to fetch CommitInfo for r0, likely missing ChangeLog") + self.assertEqual(command._blame_line_for_revision(0), "FAILED to fetch CommitInfo for r0, likely missing ChangeLog") def raising_mock(self): raise Exception("MESSAGE") tool.checkout().commit_info_for_revision = raising_mock - self.assertEquals(command._blame_line_for_revision(0), "FAILED to fetch CommitInfo for r0, exception: MESSAGE") + self.assertEqual(command._blame_line_for_revision(0), "FAILED to fetch CommitInfo for r0, exception: MESSAGE") class PrintExpectationsTest(unittest.TestCase): def run_test(self, tests, expected_stdout, platform='test-win-xp', **args): options = MockOptions(all=False, csv=False, full=False, platform=platform, - include_keyword=[], exclude_keyword=[]).update(**args) + include_keyword=[], exclude_keyword=[], paths=False).update(**args) tool = MockTool() tool.port_factory.all_port_names = lambda: TestPort.ALL_BASELINE_VARIANTS command = PrintExpectations() @@ -173,7 +173,7 @@ class PrintExpectationsTest(unittest.TestCase): command.execute(options, tests, tool) finally: stdout, _, _ = oc.restore_output() - self.assertEquals(stdout, expected_stdout) + self.assertEqual(stdout, expected_stdout) def test_basic(self): self.run_test(['failures/expected/text.html', 'failures/expected/image.html'], @@ -221,6 +221,12 @@ class PrintExpectationsTest(unittest.TestCase): 'test-win-xp,failures/expected/text.html,BUGTEST,FAIL\n'), csv=True) + def test_paths(self): + self.run_test([], + ('LayoutTests/platform/test/TestExpectations\n' + 'LayoutTests/platform/test-win-xp/TestExpectations\n'), + paths=True) + class PrintBaselinesTest(unittest.TestCase): def setUp(self): @@ -249,7 +255,7 @@ class PrintBaselinesTest(unittest.TestCase): self.capture_output() command.execute(MockOptions(all=False, include_virtual_tests=False, csv=False, platform=None), ['passes/text.html'], self.tool) stdout, _, _ = self.restore_output() - self.assertEquals(stdout, + self.assertEqual(stdout, ('// For test-win-xp\n' 'passes/text-expected.png\n' 'passes/text-expected.txt\n')) @@ -260,7 +266,7 @@ class PrintBaselinesTest(unittest.TestCase): self.capture_output() command.execute(MockOptions(all=False, include_virtual_tests=False, csv=False, platform='test-win-*'), ['passes/text.html'], self.tool) stdout, _, _ = self.restore_output() - self.assertEquals(stdout, + self.assertEqual(stdout, ('// For test-win-vista\n' 'passes/text-expected.png\n' 'passes/text-expected.txt\n' @@ -279,6 +285,6 @@ class PrintBaselinesTest(unittest.TestCase): self.capture_output() command.execute(MockOptions(all=False, platform='*xp', csv=True, include_virtual_tests=False), ['passes/text.html'], self.tool) stdout, _, _ = self.restore_output() - self.assertEquals(stdout, + self.assertEqual(stdout, ('test-win-xp,passes/text.html,None,png,passes/text-expected.png,None\n' 'test-win-xp,passes/text.html,None,txt,passes/text-expected.txt,None\n')) diff --git a/Tools/Scripts/webkitpy/tool/commands/queues.py b/Tools/Scripts/webkitpy/tool/commands/queues.py index 6993c2dea..62d429d88 100644 --- a/Tools/Scripts/webkitpy/tool/commands/queues.py +++ b/Tools/Scripts/webkitpy/tool/commands/queues.py @@ -4,7 +4,7 @@ # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: -# +# # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above @@ -14,7 +14,7 @@ # * Neither the name of Google Inc. nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. -# +# # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -352,6 +352,7 @@ class CommitQueue(AbstractPatchQueue, StepSequenceErrorHandler, CommitQueueTaskD # StepSequenceErrorHandler methods + @classmethod def handle_script_error(cls, tool, state, script_error): # Hitting this error handler should be pretty rare. It does occur, # however, when a patch no longer applies to top-of-tree in the final diff --git a/Tools/Scripts/webkitpy/tool/commands/queues_unittest.py b/Tools/Scripts/webkitpy/tool/commands/queues_unittest.py index 6301fea0b..88ab3de06 100644 --- a/Tools/Scripts/webkitpy/tool/commands/queues_unittest.py +++ b/Tools/Scripts/webkitpy/tool/commands/queues_unittest.py @@ -72,7 +72,7 @@ class TestFeederQueue(FeederQueue): class AbstractQueueTest(CommandsTest): def test_log_directory(self): - self.assertEquals(TestQueue()._log_directory(), os.path.join("..", "test-queue-logs")) + self.assertEqual(TestQueue()._log_directory(), os.path.join("..", "test-queue-logs")) def _assert_run_webkit_patch(self, run_args, port=None): queue = TestQueue() @@ -157,15 +157,15 @@ class AbstractPatchQueueTest(CommandsTest): queue.bind_to_tool(tool) queue._options = Mock() queue._options.port = None - self.assertEquals(queue._next_patch(), None) + self.assertEqual(queue._next_patch(), None) tool.status_server = MockStatusServer(work_items=[2, 10000, 10001]) expected_stdout = "MOCK: fetch_attachment: 2 is not a known attachment id\n" # A mock-only message to prevent us from making mistakes. expected_stderr = "MOCK: release_work_item: None 2\n" patch = OutputCapture().assert_outputs(self, queue._next_patch, expected_stdout=expected_stdout, expected_stderr=expected_stderr) # The patch.id() == 2 is ignored because it doesn't exist. - self.assertEquals(patch.id(), 10000) - self.assertEquals(queue._next_patch().id(), 10001) - self.assertEquals(queue._next_patch(), None) # When the queue is empty + self.assertEqual(patch.id(), 10000) + self.assertEqual(queue._next_patch().id(), 10001) + self.assertEqual(queue._next_patch(), None) # When the queue is empty def test_upload_results_archive_for_patch(self): queue = AbstractPatchQueue() @@ -377,9 +377,9 @@ MOCK: release_work_item: commit-queue 10005 state = {'patch': None} OutputCapture().assert_outputs(self, sequence.run_and_handle_errors, [tool, options, state], expected_exception=TryAgain, expected_stderr=expected_stderr) - self.assertEquals(options.update, True) - self.assertEquals(options.build, False) - self.assertEquals(options.test, False) + self.assertEqual(options.update, True) + self.assertEqual(options.build, False) + self.assertEqual(options.test, False) def test_manual_reject_during_processing(self): queue = SecondThoughtsCommitQueue(MockTool()) diff --git a/Tools/Scripts/webkitpy/tool/commands/rebaseline_unittest.py b/Tools/Scripts/webkitpy/tool/commands/rebaseline_unittest.py index d7dafb91c..cc25fae2b 100644 --- a/Tools/Scripts/webkitpy/tool/commands/rebaseline_unittest.py +++ b/Tools/Scripts/webkitpy/tool/commands/rebaseline_unittest.py @@ -88,7 +88,7 @@ class TestRebaselineTest(_BaseTestCase): self.assertEqual(command._baseline_directory("Apple Lion Release WK1 (Tests)"), "/mock-checkout/LayoutTests/platform/mac-lion") self.assertEqual(command._baseline_directory("Apple Lion Release WK2 (Tests)"), "/mock-checkout/LayoutTests/platform/mac-wk2") self.assertEqual(command._baseline_directory("GTK Linux 32-bit Release"), "/mock-checkout/LayoutTests/platform/gtk") - self.assertEqual(command._baseline_directory("EFL Linux 64-bit Debug"), "/mock-checkout/LayoutTests/platform/efl-wk1") + self.assertEqual(command._baseline_directory("EFL Linux 64-bit Release WK2"), "/mock-checkout/LayoutTests/platform/efl-wk2") self.assertEqual(command._baseline_directory("Qt Linux Release"), "/mock-checkout/LayoutTests/platform/qt") self.assertEqual(command._baseline_directory("WebKit Mac10.7"), "/mock-checkout/LayoutTests/platform/chromium-mac-lion") self.assertEqual(command._baseline_directory("WebKit Mac10.6"), "/mock-checkout/LayoutTests/platform/chromium-mac-snowleopard") @@ -105,7 +105,7 @@ Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ] self.options.suffixes = "png,wav,txt" self.command._rebaseline_test_and_update_expectations(self.options) - self.assertEquals(self.tool.web.urls_fetched, + self.assertEqual(self.tool.web.urls_fetched, [self.WEB_PREFIX + '/userscripts/another-test-actual.png', self.WEB_PREFIX + '/userscripts/another-test-actual.wav', self.WEB_PREFIX + '/userscripts/another-test-actual.txt']) @@ -121,7 +121,7 @@ Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ] self.options.suffixes = 'png,wav,txt' self.command._rebaseline_test_and_update_expectations(self.options) - self.assertEquals(self.tool.web.urls_fetched, + self.assertEqual(self.tool.web.urls_fetched, [self.WEB_PREFIX + '/userscripts/another-test-actual.png', self.WEB_PREFIX + '/userscripts/another-test-actual.wav', self.WEB_PREFIX + '/userscripts/another-test-actual.txt']) @@ -136,7 +136,7 @@ Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ] self.options.suffixes = 'png,wav,txt' self.command._rebaseline_test_and_update_expectations(self.options) - self.assertEquals(self.tool.web.urls_fetched, + self.assertEqual(self.tool.web.urls_fetched, [self.WEB_PREFIX + '/userscripts/another-test-actual.png', self.WEB_PREFIX + '/userscripts/another-test-actual.wav', self.WEB_PREFIX + '/userscripts/another-test-actual.txt']) @@ -146,13 +146,13 @@ Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ] def test_rebaseline_test(self): self.command._rebaseline_test("WebKit Linux", "userscripts/another-test.html", None, "txt", self.WEB_PREFIX) - self.assertEquals(self.tool.web.urls_fetched, [self.WEB_PREFIX + '/userscripts/another-test-actual.txt']) + self.assertEqual(self.tool.web.urls_fetched, [self.WEB_PREFIX + '/userscripts/another-test-actual.txt']) def test_rebaseline_test_with_results_directory(self): self._write(self.lion_expectations_path, "Bug(x) [ Mac ] userscripts/another-test.html [ ImageOnlyFailure ]\nbug(z) [ Linux ] userscripts/another-test.html [ ImageOnlyFailure ]\n") self.options.results_directory = '/tmp' self.command._rebaseline_test_and_update_expectations(self.options) - self.assertEquals(self.tool.web.urls_fetched, ['file:///tmp/userscripts/another-test-actual.txt']) + self.assertEqual(self.tool.web.urls_fetched, ['file:///tmp/userscripts/another-test-actual.txt']) def test_rebaseline_test_and_print_scm_changes(self): self.command._print_scm_changes = True @@ -161,20 +161,20 @@ Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ] self.command._rebaseline_test("WebKit Linux", "userscripts/another-test.html", None, "txt", None) - self.assertEquals(self.command._scm_changes, {'add': ['/mock-checkout/LayoutTests/platform/chromium-linux/userscripts/another-test-expected.txt'], 'delete': []}) + self.assertEqual(self.command._scm_changes, {'add': ['/mock-checkout/LayoutTests/platform/chromium-linux/userscripts/another-test-expected.txt'], 'delete': []}) def test_rebaseline_and_copy_test(self): self._write("userscripts/another-test-expected.txt", "generic result") self.command._rebaseline_test("WebKit Mac10.7", "userscripts/another-test.html", ["chromium-mac-snowleopard"], "txt", None) - self.assertEquals(self._read('platform/chromium-mac-lion/userscripts/another-test-expected.txt'), self.MOCK_WEB_RESULT) - self.assertEquals(self._read('platform/chromium-mac-snowleopard/userscripts/another-test-expected.txt'), 'generic result') + self.assertEqual(self._read('platform/chromium-mac-lion/userscripts/another-test-expected.txt'), self.MOCK_WEB_RESULT) + self.assertEqual(self._read('platform/chromium-mac-snowleopard/userscripts/another-test-expected.txt'), 'generic result') def test_rebaseline_and_copy_test_no_existing_result(self): self.command._rebaseline_test("WebKit Mac10.7", "userscripts/another-test.html", ["chromium-mac-snowleopard"], "txt", None) - self.assertEquals(self._read('platform/chromium-mac-lion/userscripts/another-test-expected.txt'), self.MOCK_WEB_RESULT) + self.assertEqual(self._read('platform/chromium-mac-lion/userscripts/another-test-expected.txt'), self.MOCK_WEB_RESULT) self.assertFalse(self.tool.filesystem.exists(self._expand('platform/chromium-mac-snowleopard/userscripts/another-test-expected.txt'))) def test_rebaseline_and_copy_test_with_lion_result(self): @@ -182,9 +182,9 @@ Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ] self.command._rebaseline_test("WebKit Mac10.7", "userscripts/another-test.html", ["chromium-mac-snowleopard"], "txt", self.WEB_PREFIX) - self.assertEquals(self.tool.web.urls_fetched, [self.WEB_PREFIX + '/userscripts/another-test-actual.txt']) - self.assertEquals(self._read("platform/chromium-mac-snowleopard/userscripts/another-test-expected.txt"), "original lion result") - self.assertEquals(self._read("platform/chromium-mac-lion/userscripts/another-test-expected.txt"), self.MOCK_WEB_RESULT) + self.assertEqual(self.tool.web.urls_fetched, [self.WEB_PREFIX + '/userscripts/another-test-actual.txt']) + self.assertEqual(self._read("platform/chromium-mac-snowleopard/userscripts/another-test-expected.txt"), "original lion result") + self.assertEqual(self._read("platform/chromium-mac-lion/userscripts/another-test-expected.txt"), self.MOCK_WEB_RESULT) def test_rebaseline_and_copy_no_overwrite_test(self): self._write("platform/chromium-mac-lion/userscripts/another-test-expected.txt", "original lion result") @@ -192,8 +192,8 @@ Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ] self.command._rebaseline_test("WebKit Mac10.7", "userscripts/another-test.html", ["chromium-mac-snowleopard"], "txt", None) - self.assertEquals(self._read("platform/chromium-mac-snowleopard/userscripts/another-test-expected.txt"), "original snowleopard result") - self.assertEquals(self._read("platform/chromium-mac-lion/userscripts/another-test-expected.txt"), self.MOCK_WEB_RESULT) + self.assertEqual(self._read("platform/chromium-mac-snowleopard/userscripts/another-test-expected.txt"), "original snowleopard result") + self.assertEqual(self._read("platform/chromium-mac-lion/userscripts/another-test-expected.txt"), self.MOCK_WEB_RESULT) def test_rebaseline_test_internal_with_move_overwritten_baselines_to(self): self.tool.executive = MockExecutive2() @@ -220,8 +220,8 @@ Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ] out, _, _ = oc.restore_output() builders._exact_matches = old_exact_matches - self.assertEquals(self._read(self.tool.filesystem.join(port.layout_tests_dir(), 'platform/test-mac-leopard/failures/expected/image-expected.txt')), 'original snowleopard result') - self.assertEquals(out, '{"add": []}\n') + self.assertEqual(self._read(self.tool.filesystem.join(port.layout_tests_dir(), 'platform/test-mac-leopard/failures/expected/image-expected.txt')), 'original snowleopard result') + self.assertEqual(out, '{"add": []}\n') class TestRebaselineJson(_BaseTestCase): @@ -246,7 +246,7 @@ class TestRebaselineJson(_BaseTestCase): self.command._rebaseline(options, {"user-scripts/another-test.html": {"MOCK builder": ["txt", "png"]}}) # Note that we have one run_in_parallel() call followed by a run_command() - self.assertEquals(self.tool.executive.calls, + self.assertEqual(self.tool.executive.calls, [[['echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'user-scripts/another-test.html', '--verbose']], ['echo', '--verbose', 'optimize-baselines', '--suffixes', 'txt,png', 'user-scripts/another-test.html']]) @@ -255,7 +255,7 @@ class TestRebaselineJson(_BaseTestCase): self.command._rebaseline(options, {"user-scripts/another-test.html": {"MOCK builder (Debug)": ["txt", "png"]}}) # Note that we have one run_in_parallel() call followed by a run_command() - self.assertEquals(self.tool.executive.calls, + self.assertEqual(self.tool.executive.calls, [[['echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder (Debug)', '--test', 'user-scripts/another-test.html', '--verbose']], ['echo', '--verbose', 'optimize-baselines', '--suffixes', 'txt,png', 'user-scripts/another-test.html']]) @@ -264,7 +264,7 @@ class TestRebaselineJson(_BaseTestCase): self.command._rebaseline(options, {"user-scripts/another-test.html": {"MOCK builder": ["txt", "png"]}}) # Note that we have one run_in_parallel() call followed by a run_command() - self.assertEquals(self.tool.executive.calls, + self.assertEqual(self.tool.executive.calls, [[['echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'user-scripts/another-test.html', '--move-overwritten-baselines-to', 'test-mac-leopard', '--verbose']], ['echo', '--verbose', 'optimize-baselines', '--suffixes', 'txt,png', 'user-scripts/another-test.html']]) @@ -273,7 +273,7 @@ class TestRebaselineJson(_BaseTestCase): self.command._rebaseline(options, {"user-scripts/another-test.html": {"MOCK builder (Debug)": ["txt", "png"]}}) # Note that we have only one run_in_parallel() call - self.assertEquals(self.tool.executive.calls, + self.assertEqual(self.tool.executive.calls, [[['echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder (Debug)', '--test', 'user-scripts/another-test.html', '--verbose']]]) def test_results_directory(self): @@ -281,7 +281,7 @@ class TestRebaselineJson(_BaseTestCase): self.command._rebaseline(options, {"user-scripts/another-test.html": {"MOCK builder": ["txt", "png"]}}) # Note that we have only one run_in_parallel() call - self.assertEquals(self.tool.executive.calls, + self.assertEqual(self.tool.executive.calls, [[['echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'user-scripts/another-test.html', '--results-directory', '/tmp', '--verbose']]]) @@ -313,7 +313,7 @@ class TestRebaseline(_BaseTestCase): builders._exact_matches = old_exact_matches calls = filter(lambda x: x != ['qmake', '-v'] and x[0] != 'perl', self.tool.executive.calls) - self.assertEquals(calls, + self.assertEqual(calls, [[['echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK builder', '--test', 'mock/path/to/test.html', '--verbose']]]) @@ -347,8 +347,8 @@ class TestRebaselineExpectations(_BaseTestCase): self.command.execute(self.options, [], self.tool) finally: _, _, logs = oc.restore_output() - self.assertEquals(self.tool.filesystem.written_files, {}) - self.assertEquals(logs, 'Did not find any tests marked Rebaseline.\n') + self.assertEqual(self.tool.filesystem.written_files, {}) + self.assertEqual(logs, 'Did not find any tests marked Rebaseline.\n') def disabled_test_overrides_are_included_correctly(self): # This tests that the any tests marked as REBASELINE in the overrides are found, but @@ -362,8 +362,8 @@ class TestRebaselineExpectations(_BaseTestCase): 'Bug(y) userscripts/test.html [ Crash ]\n')} self._write('/userscripts/another-test.html', '') - self.assertEquals(self.command._tests_to_rebaseline(self.lion_port), {'userscripts/another-test.html': set(['png', 'txt', 'wav'])}) - self.assertEquals(self._read(self.lion_expectations_path), '') + self.assertEqual(self.command._tests_to_rebaseline(self.lion_port), {'userscripts/another-test.html': set(['png', 'txt', 'wav'])}) + self.assertEqual(self._read(self.lion_expectations_path), '') class _FakeOptimizer(BaselineOptimizer): @@ -387,14 +387,14 @@ class TestAnalyzeBaselines(_BaseTestCase): def test_default(self): self.command.execute(MockOptions(suffixes='txt', missing=False, platform=None), ['passes/text.html'], self.tool) - self.assertEquals(self.lines, + self.assertEqual(self.lines, ['passes/text-expected.txt:', ' (generic): 123456', ' test-mac-leopard: abcdef']) def test_missing_baselines(self): self.command.execute(MockOptions(suffixes='png,txt', missing=True, platform=None), ['passes/text.html'], self.tool) - self.assertEquals(self.lines, + self.assertEqual(self.lines, ['passes/text-expected.png: (no baselines found)', 'passes/text-expected.txt:', ' (generic): 123456', diff --git a/Tools/Scripts/webkitpy/tool/commands/roll_unittest.py b/Tools/Scripts/webkitpy/tool/commands/roll_unittest.py index 800bc5b96..237a1c94f 100644 --- a/Tools/Scripts/webkitpy/tool/commands/roll_unittest.py +++ b/Tools/Scripts/webkitpy/tool/commands/roll_unittest.py @@ -56,8 +56,8 @@ class PostRollCommandsTest(CommandsTest): options = MockOptions() tool = MockTool() lkgr_state = postroll._prepare_state(options, [None, "last-known good revision"], tool) - self.assertEquals(None, lkgr_state["chromium_revision"]) - self.assertEquals("Roll Chromium DEPS to last-known good revision", lkgr_state["bug_title"]) + self.assertEqual(None, lkgr_state["chromium_revision"]) + self.assertEqual("Roll Chromium DEPS to last-known good revision", lkgr_state["bug_title"]) revision_state = postroll._prepare_state(options, ["1234", "r1234"], tool) - self.assertEquals("1234", revision_state["chromium_revision"]) - self.assertEquals("Roll Chromium DEPS to r1234", revision_state["bug_title"]) + self.assertEqual("1234", revision_state["chromium_revision"]) + self.assertEqual("Roll Chromium DEPS to r1234", revision_state["bug_title"]) diff --git a/Tools/Scripts/webkitpy/tool/servers/gardeningserver.py b/Tools/Scripts/webkitpy/tool/servers/gardeningserver.py index e89c2a08a..41b81663e 100644 --- a/Tools/Scripts/webkitpy/tool/servers/gardeningserver.py +++ b/Tools/Scripts/webkitpy/tool/servers/gardeningserver.py @@ -38,21 +38,6 @@ from webkitpy.layout_tests.port import builders _log = logging.getLogger(__name__) -class BuildCoverageExtrapolator(object): - def __init__(self, test_configuration_converter): - self._test_configuration_converter = test_configuration_converter - - @memoized - def _covered_test_configurations_for_builder_name(self): - coverage = {} - for builder_name in builders.all_builder_names(): - coverage[builder_name] = self._test_configuration_converter.to_config_set(builders.coverage_specifiers_for_builder_name(builder_name)) - return coverage - - def extrapolate_test_configurations(self, builder_name): - return self._covered_test_configurations_for_builder_name()[builder_name] - - class GardeningHTTPServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer): def __init__(self, httpd_port, config): server_name = '' @@ -63,7 +48,7 @@ class GardeningHTTPServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer def url(self, args=None): # We can't use urllib.encode() here because that encodes spaces as plus signs and the buildbots don't decode those properly. arg_string = ('?' + '&'.join("%s=%s" % (key, urllib.quote(value)) for (key, value) in args.items())) if args else '' - return 'file://' + os.path.join(GardeningHTTPRequestHandler.STATIC_FILE_DIRECTORY, 'garden-o-matic.html' + arg_string) + return 'http://localhost:8127/garden-o-matic.html' + arg_string class GardeningHTTPRequestHandler(ReflectionHandler): @@ -83,18 +68,6 @@ class GardeningHTTPRequestHandler(ReflectionHandler): allow_cross_origin_requests = True debug_output = '' - def rollout(self): - revision = self.query['revision'][0] - reason = self.query['reason'][0] - self._run_webkit_patch([ - 'rollout', - '--force-clean', - '--non-interactive', - revision, - reason, - ]) - self._serve_text('success') - def ping(self): self._serve_text('pong') @@ -139,4 +112,4 @@ class GardeningHTTPRequestHandler(ReflectionHandler): self._serve_file(fullpath, headers_only=(self.command == 'HEAD')) return - self._send_response(403) + self.send_response(403) diff --git a/Tools/Scripts/webkitpy/tool/servers/gardeningserver_unittest.py b/Tools/Scripts/webkitpy/tool/servers/gardeningserver_unittest.py index 9961648de..438cc0583 100644 --- a/Tools/Scripts/webkitpy/tool/servers/gardeningserver_unittest.py +++ b/Tools/Scripts/webkitpy/tool/servers/gardeningserver_unittest.py @@ -83,17 +83,6 @@ class TestGardeningHTTPRequestHandler(GardeningHTTPRequestHandler): print "== End JSON Response ==" -class BuildCoverageExtrapolatorTest(unittest.TestCase): - def test_extrapolate(self): - # FIXME: Make this test not rely on actual (not mock) port objects. - host = MockHost() - port = host.port_factory.get('chromium-win-win7', None) - converter = TestConfigurationConverter(port.all_test_configurations(), port.configuration_specifier_macros()) - extrapolator = BuildCoverageExtrapolator(converter) - self.assertEquals(extrapolator.extrapolate_test_configurations("WebKit XP"), set([TestConfiguration(version='xp', architecture='x86', build_type='release')])) - self.assertRaises(KeyError, extrapolator.extrapolate_test_configurations, "Potato") - - class GardeningServerTest(unittest.TestCase): def _post_to_path(self, path, body=None, expected_stderr=None, expected_stdout=None, server=None): handler = TestGardeningHTTPRequestHandler(server or MockServer()) diff --git a/Tools/Scripts/webkitpy/tool/servers/reflectionhandler.py b/Tools/Scripts/webkitpy/tool/servers/reflectionhandler.py index 930870961..2148b4eb2 100644 --- a/Tools/Scripts/webkitpy/tool/servers/reflectionhandler.py +++ b/Tools/Scripts/webkitpy/tool/servers/reflectionhandler.py @@ -44,8 +44,8 @@ import BaseHTTPServer class ReflectionHandler(BaseHTTPServer.BaseHTTPRequestHandler): + STATIC_FILE_EXTENSIONS = ['.js', '.css', '.html'] # Subclasses should override. - STATIC_FILE_NAMES = None STATIC_FILE_DIRECTORY = None # Setting this flag to True causes the server to send @@ -78,7 +78,8 @@ class ReflectionHandler(BaseHTTPServer.BaseHTTPRequestHandler): self.query = {} function_or_file_name = path[1:] or "index.html" - if function_or_file_name in self.STATIC_FILE_NAMES: + _, extension = os.path.splitext(self.path) + if extension in self.STATIC_FILE_EXTENSIONS: self._serve_static_file(function_or_file_name) return diff --git a/Tools/Scripts/webkitpy/tool/servers/reflectionhandler_unittest.py b/Tools/Scripts/webkitpy/tool/servers/reflectionhandler_unittest.py new file mode 100644 index 000000000..d269dfcf5 --- /dev/null +++ b/Tools/Scripts/webkitpy/tool/servers/reflectionhandler_unittest.py @@ -0,0 +1,70 @@ +# Copyright (C) 2012 Google Inc. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import unittest + +from webkitpy.tool.servers.reflectionhandler import ReflectionHandler + + +class TestReflectionHandler(ReflectionHandler): + STATIC_FILE_DIRECTORY = "/" + + def __init__(self): + self.static_files_served = set() + self.errors_sent = set() + self.functions_run = set() + + def _serve_static_file(self, name): + self.static_files_served.add(name) + + def send_error(self, code, description): + self.errors_sent.add(code) + + def function_one(self): + self.functions_run.add("function_one") + + def some_html(self): + self.functions_run.add("some_html") + + +class ReflectionHandlerTest(unittest.TestCase): + def assert_handler_response(self, requests, expected_static_files, expected_errors, expected_functions): + handler = TestReflectionHandler() + for request in requests: + handler.path = request + handler._handle_request() + self.assertEqual(handler.static_files_served, expected_static_files) + self.assertEqual(handler.errors_sent, expected_errors) + self.assertEqual(handler.functions_run, expected_functions) + + def test_static_content_or_function_switch(self): + self.assert_handler_response(["/test.js"], set(["test.js"]), set(), set()) + self.assert_handler_response(["/test.js", "/test.css", "/test.html"], set(["test.js", "test.html", "test.css"]), set(), set()) + self.assert_handler_response(["/test.js", "/test.exe", "/testhtml"], set(["test.js"]), set([404]), set()) + self.assert_handler_response(["/test.html", "/function.one"], set(["test.html"]), set(), set(['function_one'])) + self.assert_handler_response(["/some.html"], set(["some.html"]), set(), set()) diff --git a/Tools/Scripts/webkitpy/tool/steps/addsvnmimetypeforpng_unittest.py b/Tools/Scripts/webkitpy/tool/steps/addsvnmimetypeforpng_unittest.py index 221c6bc94..9fab6f438 100644 --- a/Tools/Scripts/webkitpy/tool/steps/addsvnmimetypeforpng_unittest.py +++ b/Tools/Scripts/webkitpy/tool/steps/addsvnmimetypeforpng_unittest.py @@ -55,4 +55,4 @@ class AddSvnMimetypeForPngTest(unittest.TestCase): try: capture.assert_outputs(self, step.run, [state]) except SystemExit, e: - self.assertEquals(e.code, 1) + self.assertEqual(e.code, 1) diff --git a/Tools/Scripts/webkitpy/tool/steps/preparechangelog_unittest.py b/Tools/Scripts/webkitpy/tool/steps/preparechangelog_unittest.py index 847dc2f93..fc31d1fa9 100644 --- a/Tools/Scripts/webkitpy/tool/steps/preparechangelog_unittest.py +++ b/Tools/Scripts/webkitpy/tool/steps/preparechangelog_unittest.py @@ -54,4 +54,4 @@ class PrepareChangeLogTest(changelog_unittest.ChangeLogTest): expected_message = "Example title\n http://example.com/1234" expected_contents = changelog_contents.replace("Need a short description (OOPS!).\n Need the bug URL (OOPS!).", expected_message) os.remove(changelog_path) - self.assertEquals(actual_contents.splitlines(), expected_contents.splitlines()) + self.assertEqual(actual_contents.splitlines(), expected_contents.splitlines()) diff --git a/Tools/Scripts/webkitpy/tool/steps/preparechangelogforrevert_unittest.py b/Tools/Scripts/webkitpy/tool/steps/preparechangelogforrevert_unittest.py index 076e60252..b82cb4aa2 100644 --- a/Tools/Scripts/webkitpy/tool/steps/preparechangelogforrevert_unittest.py +++ b/Tools/Scripts/webkitpy/tool/steps/preparechangelogforrevert_unittest.py @@ -115,11 +115,11 @@ class UpdateChangeLogsForRevertTest(unittest.TestCase): changelog.update_with_unreviewed_message(PrepareChangeLogForRevert._message_for_revert(*args)) actual_entry = changelog.latest_entry() os.remove(changelog_path) - self.assertEquals(actual_entry.contents(), expected_entry) - self.assertEquals(actual_entry.reviewer_text(), None) + self.assertEqual(actual_entry.contents(), expected_entry) + self.assertEqual(actual_entry.reviewer_text(), None) # These checks could be removed to allow this to work on other entries: - self.assertEquals(actual_entry.author_name(), "Eric Seidel") - self.assertEquals(actual_entry.author_email(), "eric@webkit.org") + self.assertEqual(actual_entry.author_name(), "Eric Seidel") + self.assertEqual(actual_entry.author_email(), "eric@webkit.org") def test_message_for_revert(self): self._assert_message_for_revert_output([[12345], "Reason"], self._revert_entry_without_bug_url) diff --git a/Tools/TestResultServer/generate_builders_json.py b/Tools/TestResultServer/generate_builders_json.py new file mode 100644 index 000000000..9be6552ce --- /dev/null +++ b/Tools/TestResultServer/generate_builders_json.py @@ -0,0 +1,123 @@ +#!/usr/bin/env python +# Copyright (C) 2011 Google Inc. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import json +import logging +import optparse +import os +import urllib2 + +# FIXME: See if Tools/Scripts/webkitpy/layout_tests/port/builders.py should also read +# the output json file here as its data source. + + +def master_json_url(master_url): + return master_url + '/json/builders' + + +def builder_json_url(master_url, builder): + return master_json_url(master_url) + '/' + urllib2.quote(builder) + + +def cached_build_json_url(master_url, builder, build_number): + return builder_json_url(master_url, builder) + '/builds/' + str(build_number) + + +def fetch_json(url): + logging.debug('Fetching %s' % url) + return json.load(urllib2.urlopen(url)) + + +def insert_builder_and_test_data(masters): + for master in masters: + master_url = master['url'] + tests_object = {} + master['tests'] = tests_object + + for builder in fetch_json(master_json_url(master_url)): + build_data = fetch_json(builder_json_url(master_url, builder)) + cached_builds = build_data['cachedBuilds'] + current_builds = build_data['currentBuilds'] + + latest_cached_build = cached_builds.pop() + while latest_cached_build in current_builds and len(cached_builds): + latest_cached_build = cached_builds.pop() + + for step in fetch_json(cached_build_json_url(master_url, builder, latest_cached_build))['steps']: + step_name = step['name'] + + # The chromium bots call this step webkit-tests, the webkit.org bots call it layout-test. :( + # The files stored at test-results.appspot.com use layout-tests as the test suite name, so normalize to that. + if step_name in ['layout-test', 'webkit_tests']: + step_name = 'layout-tests' + + is_test = step_name == 'layout-tests' if master['name'] == 'webkit.org' else 'test' in step_name and 'archive' not in step_name + if not is_test: + continue + + if step_name not in tests_object: + tests_object[step_name] = {'builders': []} + tests_object[step_name]['builders'].append(builder) + + for step_name in tests_object: + tests_object[step_name]['builders'].sort() + + +def main(): + option_parser = optparse.OptionParser() + option_parser.add_option('-v', '--verbose', action='store_true', default=False, help='Print debug logging') + options, args = option_parser.parse_args() + + logging.getLogger().setLevel(logging.DEBUG if options.verbose else logging.INFO) + + masters = [ + {'name': 'ChromiumWin', 'url': 'http://build.chromium.org/p/chromium.win'}, + {'name': 'ChromiumMac', 'url': 'http://build.chromium.org/p/chromium.mac'}, + {'name': 'ChromiumLinux', 'url': 'http://build.chromium.org/p/chromium.linux'}, + {'name': 'ChromiumChromiumOS', 'url': 'http://build.chromium.org/p/chromium.chromiumos'}, + {'name': 'ChromiumGPU', 'url': 'http://build.chromium.org/p/chromium.gpu'}, + {'name': 'ChromiumGPUFYI', 'url': 'http://build.chromium.org/p/chromium.gpu.fyi'}, + {'name': 'ChromiumPerfAv', 'url': 'http://build.chromium.org/p/chromium.perf_av'}, + {'name': 'ChromiumWebkit', 'url': 'http://build.chromium.org/p/chromium.webkit'}, + {'name': 'webkit.org', 'url': 'http://build.webkit.org'}, + ] + + insert_builder_and_test_data(masters) + + json_file_prefix = ('// This file is auto-generated by Tools/TestResultServer/generate_builders_json.py. It should not be manually modified.\n' + '// It uses jsonp instead of proper json because we want to be able to load it from a file URL in Chrome for local testing.\n' + 'LOAD_BUILDBOT_DATA(') + json_file_suffix = ');\n'; + + json_file = open(os.path.join('static-dashboards', 'builders.jsonp'), 'w') + json_file.write(json_file_prefix + json.dumps(masters, separators=(', ', ': '), indent=4, sort_keys=True) + json_file_suffix) + + +if __name__ == "__main__": + main() diff --git a/Tools/TestResultServer/generate_builders_json_unittest.py b/Tools/TestResultServer/generate_builders_json_unittest.py new file mode 100644 index 000000000..588c9397f --- /dev/null +++ b/Tools/TestResultServer/generate_builders_json_unittest.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python +# Copyright (C) 2012 Google Inc. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import logging +import unittest + +import generate_builders_json + + +class GenerateBuildersJsonTest(unittest.TestCase): + + def test_master_json_url(self): + self.assertEqual(generate_builders_json.master_json_url('http://base'), 'http://base/json/builders') + + def test_builder_json_url(self): + self.assertEqual(generate_builders_json.builder_json_url('http://base', 'dummybuilder'), 'http://base/json/builders/dummybuilder') + + def test_cached_build_json_url(self): + self.assertEqual(generate_builders_json.cached_build_json_url('http://base', 'dummybuilder', 12345), 'http://base/json/builders/dummybuilder/builds/12345') + self.assertEqual(generate_builders_json.cached_build_json_url('http://base', 'dummybuilder', '12345'), 'http://base/json/builders/dummybuilder/builds/12345') + + def test_generate_json_data(self): + try: + old_fetch_json = generate_builders_json.fetch_json + + fetched_urls = [] + + def dummy_fetch_json(url): + fetched_urls.append(url) + + if url == 'http://build.chromium.org/p/chromium.webkit/json/builders': + return {'WebKit Win': None, 'WebKit Linux': None, 'WebKit Mac': None} + if url == 'http://build.webkit.org/json/builders': + return {'Apple Mac SnowLeopard Tests': None, 'Chromium Mac Builder': None, 'GTK': None} + + if url == 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Linux': + return {'cachedBuilds': [1, 2], 'currentBuilds': []} + if url == 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Win': + return {'cachedBuilds': [1, 2], 'currentBuilds': []} + if url == 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Mac': + return {'cachedBuilds': [1, 2], 'currentBuilds': []} + if url == 'http://build.webkit.org/json/builders/Apple%20Mac%20SnowLeopard%20Tests': + return {'cachedBuilds': [1, 2], 'currentBuilds': []} + if url == 'http://build.webkit.org/json/builders/Chromium%20Mac%20Builder': + return {'cachedBuilds': [1, 2, 3], 'currentBuilds': [3]} + if url == 'http://build.webkit.org/json/builders/GTK': + return {'cachedBuilds': [2], 'currentBuilds': []} + + if url == 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Linux/builds/2': + return {'steps': [{'name': 'webkit_tests'}, {'name': 'browser_tests'}, {'name': 'mini_installer_test'}, {'name': 'archive_test_results'}, {'name': 'compile'}]} + if url == 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Win/builds/2': + return {'steps': [{'name': 'webkit_tests'}, {'name': 'mini_installer_test'}, {'name': 'archive_test_results'}, {'name': 'compile'}]} + if url == 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Mac/builds/2': + return {'steps': [{'name': 'browser_tests'}, {'name': 'mini_installer_test'}, {'name': 'archive_test_results'}, {'name': 'compile'}]} + if url == 'http://build.webkit.org/json/builders/Apple%20Mac%20SnowLeopard%20Tests/builds/2': + return {'steps': [{'name': 'layout-test'}, {'name': 'archive_test_results'}, {'name': 'compile'}]} + if url == 'http://build.webkit.org/json/builders/Chromium%20Mac%20Builder/builds/2': + return {'steps': [{'name': 'compile'}]} + if url == 'http://build.webkit.org/json/builders/GTK/builds/2': + return {'steps': [{'name': 'layout-test'}, {'name': 'archive_test_results'}, {'name': 'compile'}]} + + logging.error('Cannot fetch fake url: %s' % url) + + generate_builders_json.fetch_json = dummy_fetch_json + + masters = [ + {'name': 'ChromiumWebkit', 'url': 'http://build.chromium.org/p/chromium.webkit'}, + {'name': 'webkit.org', 'url': 'http://build.webkit.org'}, + ] + + generate_builders_json.insert_builder_and_test_data(masters) + + expected_fetched_urls = [ + 'http://build.chromium.org/p/chromium.webkit/json/builders', + 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Linux', + 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Linux/builds/2', + 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Mac', + 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Mac/builds/2', + 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Win', + 'http://build.chromium.org/p/chromium.webkit/json/builders/WebKit%20Win/builds/2', + 'http://build.webkit.org/json/builders', + 'http://build.webkit.org/json/builders/Apple%20Mac%20SnowLeopard%20Tests', + 'http://build.webkit.org/json/builders/Apple%20Mac%20SnowLeopard%20Tests/builds/2', + 'http://build.webkit.org/json/builders/GTK', + 'http://build.webkit.org/json/builders/GTK/builds/2', + 'http://build.webkit.org/json/builders/Chromium%20Mac%20Builder', + 'http://build.webkit.org/json/builders/Chromium%20Mac%20Builder/builds/2'] + self.assertEqual(fetched_urls, expected_fetched_urls) + + expected_masters = [ + { + 'url': 'http://build.chromium.org/p/chromium.webkit', + 'tests': { + 'browser_tests': {'builders': ['WebKit Linux', 'WebKit Mac']}, + 'mini_installer_test': {'builders': ['WebKit Linux', 'WebKit Mac', 'WebKit Win']}, + 'layout-tests': {'builders': ['WebKit Linux', 'WebKit Win']}}, + 'name': 'ChromiumWebkit'}, + { + 'url': 'http://build.webkit.org', + 'tests': { + 'layout-tests': {'builders': ['Apple Mac SnowLeopard Tests', 'GTK']}}, + 'name': 'webkit.org'}] + self.assertEqual(masters, expected_masters) + + finally: + generate_builders_json.fetch_json = old_fetch_json + +if __name__ == '__main__': + unittest.main() diff --git a/Tools/TestResultServer/model/jsonresults_unittest.py b/Tools/TestResultServer/model/jsonresults_unittest.py index 4d5fa9de9..0e65d0bf2 100755 --- a/Tools/TestResultServer/model/jsonresults_unittest.py +++ b/Tools/TestResultServer/model/jsonresults_unittest.py @@ -127,7 +127,7 @@ class JsonResultsTest(unittest.TestCase): if expected_data: expected_results = self._make_test_json(expected_data) - self.assertEquals(merged_results, expected_results) + self.assertEqual(merged_results, expected_results) else: self.assertFalse(merged_results) @@ -135,7 +135,7 @@ class JsonResultsTest(unittest.TestCase): input_results = self._make_test_json(input_data) expected_results = JSON_RESULTS_TEST_LIST_TEMPLATE.replace("{[TESTDATA_TESTS]}", simplejson.dumps(expected_data, separators=(',', ':'))) actual_results = JsonResults.get_test_list(self._builder, input_results) - self.assertEquals(actual_results, expected_results) + self.assertEqual(actual_results, expected_results) def test_merge_null_incremental_results(self): # Empty incremental results json. diff --git a/Tools/TestResultServer/static-dashboards/builders.js b/Tools/TestResultServer/static-dashboards/builders.js index 2a6b67d14..97dfe2729 100644 --- a/Tools/TestResultServer/static-dashboards/builders.js +++ b/Tools/TestResultServer/static-dashboards/builders.js @@ -29,31 +29,71 @@ // @fileoverview File that lists builders, their masters, and logical groupings // of them. -function BuilderMaster(name, basePath) +function LOAD_BUILDBOT_DATA(builderData) { - this.name = name; - this.basePath = basePath; + builders.masters = {}; + builderData.forEach(function(master) { + builders.masters[master.name] = new builders.BuilderMaster(master.name, master.url, master.tests); + }) } -BuilderMaster.prototype.logPath = function(builder, buildNumber) +var builders = builders || {}; + +(function() { + +// FIXME: Move some of this loading logic into loader.js. + +builders._loadScript = function(url, success, error) { - return this.basePath + 'builders/' + builder + '/builds/' + buildNumber; -}; + var script = document.createElement('script'); + script.src = url; + script.onload = success; + script.onerror = error; + document.head.appendChild(script); +} -BuilderMaster.prototype.builderJsonPath = function() +builders._requestBuilders = function() { - return this.basePath + 'json/builders'; -}; + var buildersUrl = 'builders.jsonp'; + builders._loadScript(buildersUrl, function() {}, function() { + console.error('Could not load ' + buildersUrl); + }); +} + + +builders.BuilderMaster = function(name, basePath, tests) +{ + this.name = name; + this.basePath = basePath; + this.tests = tests; +} + +builders.BuilderMaster.prototype = { + logPath: function(builder, buildNumber) + { + return this.basePath + '/builders/' + builder + '/builds/' + buildNumber; + }, + builderJsonPath: function() + { + return this.basePath + '/json/builders'; + }, +} + +builders._requestBuilders(); + +})(); -CHROMIUM_WIN_BUILDER_MASTER = new BuilderMaster('ChromiumWin', 'http://build.chromium.org/p/chromium.win/'); -CHROMIUM_MAC_BUILDER_MASTER = new BuilderMaster('ChromiumMac', 'http://build.chromium.org/p/chromium.mac/'); -CHROMIUM_LINUX_BUILDER_MASTER = new BuilderMaster('ChromiumLinux', 'http://build.chromium.org/p/chromium.linux/'); -CHROMIUMOS_BUILDER_MASTER = new BuilderMaster('ChromiumChromiumOS', 'http://build.chromium.org/p/chromium.chromiumos/'); -CHROMIUM_GPU_BUILDER_MASTER = new BuilderMaster('ChromiumGPU', 'http://build.chromium.org/p/chromium.gpu/'); -CHROMIUM_GPU_FYI_BUILDER_MASTER = new BuilderMaster('ChromiumGPUFYI', 'http://build.chromium.org/p/chromium.gpu.fyi/'); -CHROMIUM_PERF_AV_BUILDER_MASTER = new BuilderMaster('ChromiumPerfAv', 'http://build.chromium.org/p/chromium.perf_av/'); -CHROMIUM_WEBKIT_BUILDER_MASTER = new BuilderMaster('ChromiumWebkit', 'http://build.chromium.org/p/chromium.webkit/'); -WEBKIT_BUILDER_MASTER = new BuilderMaster('webkit.org', 'http://build.webkit.org/'); +// FIXME: Move everything below into the anonymous namespace above. + +CHROMIUM_WIN_BUILDER_MASTER = 'ChromiumWin'; +CHROMIUM_MAC_BUILDER_MASTER = 'ChromiumMac'; +CHROMIUM_LINUX_BUILDER_MASTER = 'ChromiumLinux'; +CHROMIUMOS_BUILDER_MASTER = 'ChromiumChromiumOS'; +CHROMIUM_GPU_BUILDER_MASTER = 'ChromiumGPU'; +CHROMIUM_GPU_FYI_BUILDER_MASTER = 'ChromiumGPUFYI'; +CHROMIUM_PERF_AV_BUILDER_MASTER = 'ChromiumPerfAv'; +CHROMIUM_WEBKIT_BUILDER_MASTER = 'ChromiumWebkit'; +WEBKIT_BUILDER_MASTER = 'webkit.org'; var LEGACY_BUILDER_MASTERS_TO_GROUPS = { 'Chromium': '@DEPS - chromium.org', @@ -74,88 +114,56 @@ function BuilderGroup(isToTWebKit) // Map of builderName (the name shown in the waterfall) to builderPath (the // path used in the builder's URL) this.builders = {}; - this.groups = 0; - this.expectedGroups = 0; } -BuilderGroup.prototype.setbuilder = function(builder, flags) { - this.builders[builder] = builder.replace(/[ .()]/g, '_'); - // FIXME: Remove this at some point, we don't actually use DEFAULT_BUILDER - // in any meaningful way anymore. We always just default to the - // first builder in alphabetical order. - if (flags & BuilderGroup.DEFAULT_BUILDER) - this.defaultBuilder = builder; -}; - BuilderGroup.prototype.append = function(builders) { - builders.forEach(function(builderAndFlags) { - var builder = builderAndFlags[0]; - var flags = builderAndFlags[1]; - this.setbuilder(builder, flags); + builders.forEach(function(builderName) { + this.builders[builderName] = builderName.replace(/[ .()]/g, '_'); }, this); - this.groups += 1; }; -BuilderGroup.prototype.loaded = function() { - return this.groups >= this.expectedGroups; -} - BuilderGroup.prototype.setup = function() { // FIXME: instead of copying these to globals, it would be better if // the rest of the code read things from the BuilderGroup instance directly - g_defaultBuilderName = this.defaultBuilder; + g_defaultBuilderName = this._defaultBuilder(); g_builders = this.builders; }; -BuilderGroup.TOT_WEBKIT = true; -BuilderGroup.DEPS_WEBKIT = false; -BuilderGroup.DEFAULT_BUILDER = 1 << 1; - -var BUILDER_TO_MASTER = {}; -function associateBuildersWithMaster(builders, master) +BuilderGroup.prototype._defaultBuilder = function() { - builders.forEach(function(builderAndFlags) { - var builder = builderAndFlags[0]; - BUILDER_TO_MASTER[builder] = master; - }); + for (var builder in this.builders) + return builder; + console.error('There are no builders in this builder group.'); } -function requestBuilderList(builderGroups, builderFilter, master, groupName, builderGroup) +BuilderGroup.prototype.master = function() { - if (!builderGroups[groupName]) - builderGroups[groupName] = builderGroup; - loader.request(master.builderJsonPath(), - partial(onBuilderListLoad, builderGroups, builderFilter, master, groupName), - partial(onErrorLoadingBuilderList, master.builderJsonPath(), builderGroups, groupName)); - builderGroups[groupName].expectedGroups += 1; + return builderMaster(this._defaultBuilder()); } -function isChromiumDepsGpuTestRunner(builder) -{ - return true; -} +BuilderGroup.TOT_WEBKIT = true; +BuilderGroup.DEPS_WEBKIT = false; -function isChromiumDepsFyiGpuTestRunner(builder) -{ - // FIXME: This is kind of wonky, but there's not really a better pattern. - return builder.indexOf('(') != -1; -} +var BUILDER_TO_MASTER = {}; -function isChromiumTipOfTreeGpuTestRunner(builder) +function builderMaster(builderName) { - return builder.indexOf('GPU') != -1; + return BUILDER_TO_MASTER[builderName]; } -function isWebkitTestRunner(builder) +function requestBuilderList(builderGroups, masterName, groupName, builderGroup, testType, opt_builderFilter) { - if (builder.indexOf('EFL') != -1) - return builder.indexOf('Build') == -1; - if (builder.indexOf('Tests') != -1) { - // Apple Windows bots still run old-run-webkit-tests, so they don't upload data. - return builder.indexOf('Win') == -1 || (builder.indexOf('Qt') != -1 && builder.indexOf('Chromium') != -1); - } - return builder.indexOf('GTK') != -1 || builder == 'Qt Linux Release'; + if (!builderGroups[groupName]) + builderGroups[groupName] = builderGroup; + var master = builders.masters[masterName]; + var builderList = master.tests[testType].builders; + if (opt_builderFilter) + builderList = builderList.filter(opt_builderFilter); + builderList.forEach(function(builderName) { + BUILDER_TO_MASTER[builderName] = master; + }); + builderGroups[groupName].append(builderList); } function isChromiumContentShellTestRunner(builder) @@ -166,61 +174,15 @@ function isChromiumContentShellTestRunner(builder) function isChromiumWebkitTipOfTreeTestRunner(builder) { // FIXME: Remove the Android check once the android tests bot is actually uploading results. - return builder.indexOf('WebKit') != -1 && builder.indexOf('Builder') == -1 && builder.indexOf('(deps)') == -1 && - builder.indexOf('ASAN') == -1 && !isChromiumContentShellTestRunner(builder) && builder.indexOf('Android') == -1; + return builder.indexOf('ASAN') == -1 && !isChromiumContentShellTestRunner(builder) && builder.indexOf('Android') == -1 && !isChromiumWebkitDepsTestRunner(builder); } function isChromiumWebkitDepsTestRunner(builder) { - return builder.indexOf('WebKit') != -1 && builder.indexOf('Builder') == -1 && builder.indexOf('(deps)') != -1; -} - -function isChromiumDepsGTestRunner(builder) -{ - return builder.indexOf('Builder') == -1; -} - -function isChromiumDepsCrosGTestRunner(builder) -{ - return builder.indexOf('Tests') != -1; -} - -function isChromiumTipOfTreeGTestRunner(builder) -{ - return !isChromiumTipOfTreeGpuTestRunner(builder) && builder.indexOf('Builder') == -1 && builder.indexOf('Perf') == -1 && - builder.indexOf('WebKit') == -1 && builder.indexOf('Valgrind') == -1 && builder.indexOf('Chrome Frame') == -1; -} - -function isChromiumDepsAVTestRunner(builder) -{ - return builder.indexOf('Builder') == -1; -} - -function generateBuildersFromBuilderList(builderList, filter) -{ - return builderList.filter(filter).map(function(tester, index) { - var builder = [tester]; - if (!index) - builder.push(BuilderGroup.DEFAULT_BUILDER); - return builder; - }); -} - -function onBuilderListLoad(builderGroups, builderFilter, master, groupName, xhr) -{ - var builders = generateBuildersFromBuilderList(Object.keys(JSON.parse(xhr.responseText)), builderFilter); - associateBuildersWithMaster(builders, master); - builderGroups[groupName].append(builders); - if (builderGroups[groupName].loaded()) - g_resourceLoader.buildersListLoaded(); -} - -function onErrorLoadingBuilderList(url, builderGroups, groupName, xhr) -{ - builderGroups[groupName].groups += 1; - console.log('Could not load list of builders from ' + url + '. Try reloading.'); + return builder.indexOf('(deps)') != -1; } +// FIXME: Look into whether we can move the grouping logic into builders.jsonp and get rid of this code. function loadBuildersList(groupName, testType) { switch (testType) { case 'gl_tests': @@ -228,17 +190,17 @@ function loadBuildersList(groupName, testType) { switch(groupName) { case '@DEPS - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.DEPS_WEBKIT); - requestBuilderList(CHROMIUM_GPU_TESTS_BUILDER_GROUPS, isChromiumDepsGpuTestRunner, CHROMIUM_GPU_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(CHROMIUM_GPU_TESTS_BUILDER_GROUPS, CHROMIUM_GPU_BUILDER_MASTER, groupName, builderGroup, testType); break; case '@DEPS FYI - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.DEPS_WEBKIT); - requestBuilderList(CHROMIUM_GPU_TESTS_BUILDER_GROUPS, isChromiumDepsFyiGpuTestRunner, CHROMIUM_GPU_FYI_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(CHROMIUM_GPU_TESTS_BUILDER_GROUPS, CHROMIUM_GPU_FYI_BUILDER_MASTER, groupName, builderGroup, testType); break; case '@ToT - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.TOT_WEBKIT); - requestBuilderList(CHROMIUM_GPU_TESTS_BUILDER_GROUPS, isChromiumTipOfTreeGpuTestRunner, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(CHROMIUM_GPU_TESTS_BUILDER_GROUPS, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup, testType); break; } break; @@ -247,39 +209,38 @@ function loadBuildersList(groupName, testType) { switch(groupName) { case 'Content Shell @ToT - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.TOT_WEBKIT); - requestBuilderList(LAYOUT_TESTS_BUILDER_GROUPS, isChromiumContentShellTestRunner, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(LAYOUT_TESTS_BUILDER_GROUPS, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup, testType, isChromiumContentShellTestRunner); break; case '@ToT - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.TOT_WEBKIT); - requestBuilderList(LAYOUT_TESTS_BUILDER_GROUPS, isChromiumWebkitTipOfTreeTestRunner, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(LAYOUT_TESTS_BUILDER_GROUPS, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup, testType, isChromiumWebkitTipOfTreeTestRunner); break; case '@ToT - webkit.org': var builderGroup = new BuilderGroup(BuilderGroup.TOT_WEBKIT); - requestBuilderList(LAYOUT_TESTS_BUILDER_GROUPS, isWebkitTestRunner, WEBKIT_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(LAYOUT_TESTS_BUILDER_GROUPS, WEBKIT_BUILDER_MASTER, groupName, builderGroup, testType); break; case '@DEPS - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.DEPS_WEBKIT); - requestBuilderList(LAYOUT_TESTS_BUILDER_GROUPS, isChromiumWebkitDepsTestRunner, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup); - requestBuilderList(LAYOUT_TESTS_BUILDER_GROUPS, isChromiumDepsAVTestRunner, CHROMIUM_PERF_AV_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(LAYOUT_TESTS_BUILDER_GROUPS, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup, testType, isChromiumWebkitDepsTestRunner); + requestBuilderList(LAYOUT_TESTS_BUILDER_GROUPS, CHROMIUM_PERF_AV_BUILDER_MASTER, groupName, builderGroup, testType); break; } break; - + case 'test_shell_tests': case 'webkit_unit_tests': switch(groupName) { case '@ToT - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.TOT_WEBKIT); - requestBuilderList(TEST_SHELL_TESTS_BUILDER_GROUPS, isChromiumWebkitTipOfTreeTestRunner, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(TEST_SHELL_TESTS_BUILDER_GROUPS, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup, testType, isChromiumWebkitTipOfTreeTestRunner); break; case '@DEPS - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.DEPS_WEBKIT); - requestBuilderList(TEST_SHELL_TESTS_BUILDER_GROUPS, isChromiumWebkitDepsTestRunner, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup); - requestBuilderList(TEST_SHELL_TESTS_BUILDER_GROUPS, isChromiumDepsAVTestRunner, CHROMIUM_PERF_AV_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(TEST_SHELL_TESTS_BUILDER_GROUPS, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup, testType, isChromiumWebkitDepsTestRunner); break; } break; @@ -288,19 +249,19 @@ function loadBuildersList(groupName, testType) { switch(groupName) { case '@DEPS - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.DEPS_WEBKIT); - requestBuilderList(CHROMIUM_GTESTS_BUILDER_GROUPS, isChromiumDepsGTestRunner, CHROMIUM_WIN_BUILDER_MASTER, groupName, builderGroup); - requestBuilderList(CHROMIUM_GTESTS_BUILDER_GROUPS, isChromiumDepsGTestRunner, CHROMIUM_MAC_BUILDER_MASTER, groupName, builderGroup); - requestBuilderList(CHROMIUM_GTESTS_BUILDER_GROUPS, isChromiumDepsGTestRunner, CHROMIUM_LINUX_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(CHROMIUM_GTESTS_BUILDER_GROUPS, CHROMIUM_WIN_BUILDER_MASTER, groupName, builderGroup, testType); + requestBuilderList(CHROMIUM_GTESTS_BUILDER_GROUPS, CHROMIUM_MAC_BUILDER_MASTER, groupName, builderGroup, testType); + requestBuilderList(CHROMIUM_GTESTS_BUILDER_GROUPS, CHROMIUM_LINUX_BUILDER_MASTER, groupName, builderGroup, testType); break; case '@DEPS CrOS - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.DEPS_WEBKIT); - requestBuilderList(CHROMIUM_GTESTS_BUILDER_GROUPS, isChromiumDepsCrosGTestRunner, CHROMIUMOS_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(CHROMIUM_GTESTS_BUILDER_GROUPS, CHROMIUMOS_BUILDER_MASTER, groupName, builderGroup, testType); break; case '@ToT - chromium.org': var builderGroup = new BuilderGroup(BuilderGroup.TOT_WEBKIT); - requestBuilderList(CHROMIUM_GTESTS_BUILDER_GROUPS, isChromiumTipOfTreeGTestRunner, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup); + requestBuilderList(CHROMIUM_GTESTS_BUILDER_GROUPS, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, builderGroup, testType); break; } break; diff --git a/Tools/TestResultServer/static-dashboards/builders.jsonp b/Tools/TestResultServer/static-dashboards/builders.jsonp new file mode 100644 index 000000000..a813db093 --- /dev/null +++ b/Tools/TestResultServer/static-dashboards/builders.jsonp @@ -0,0 +1,1516 @@ +// This file is auto-generated by Tools/TestResultServer/generate_builders_json.py. It should not be manually modified. +// It uses jsonp instead of proper json because we want to be able to load it from a file URL in Chrome for local testing. +LOAD_BUILDBOT_DATA([ + { + "name": "ChromiumWin", + "tests": { + "ash_unittests": { + "builders": [ + "Win Aura" + ] + }, + "aura_unittests": { + "builders": [ + "Win Aura" + ] + }, + "base_unittests": { + "builders": [ + "Win7 Tests (dbg)(1)", + "Win7 Tests (2)", + "XP Tests (2)", + "Vista Tests (2)", + "XP Tests (dbg)(1)" + ] + }, + "browser_tests": { + "builders": [ + "XP Tests (dbg)(5)", + "XP Tests (1)", + "Win7 Tests (dbg)(3)", + "Win7 Tests (dbg)(5)", + "Win7 Tests (2)", + "XP Tests (3)", + "Vista Tests (1)", + "Vista Tests (3)", + "XP Tests (2)", + "XP Tests (dbg)(2)", + "Win7 Tests (dbg)(6)", + "XP Tests (dbg)(6)", + "XP Tests (dbg)(4)", + "Win7 Tests (dbg)(4)", + "Win7 Tests (3)", + "Win7 Tests (dbg)(2)", + "Vista Tests (2)", + "Win7 Tests (1)", + "XP Tests (dbg)(3)", + "Win Aura" + ] + }, + "cacheinvalidation_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "cc_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "chrome_frame_net_tests": { + "builders": [ + "Chrome Frame Tests (ie8)", + "Chrome Frame Tests (ie6)", + "Chrome Frame Tests (ie7)", + "Chrome Frame Tests (ie9)" + ] + }, + "chrome_frame_tests": { + "builders": [ + "Chrome Frame Tests (ie8)", + "Chrome Frame Tests (ie6)", + "Chrome Frame Tests (ie7)", + "Chrome Frame Tests (ie9)" + ] + }, + "chrome_frame_unittests": { + "builders": [ + "Chrome Frame Tests (ie8)", + "Chrome Frame Tests (ie6)", + "Chrome Frame Tests (ie7)", + "Chrome Frame Tests (ie9)" + ] + }, + "compositor_unittests": { + "builders": [ + "Win Aura" + ] + }, + "content_browsertests": { + "builders": [ + "XP Tests (1)", + "Vista Tests (1)", + "XP Tests (dbg)(2)", + "Win7 Tests (dbg)(2)", + "Win7 Tests (1)", + "Win Aura" + ] + }, + "content_unittests": { + "builders": [ + "Win7 Tests (dbg)(1)", + "XP Tests (3)", + "Vista Tests (3)", + "Win7 Tests (3)", + "Win Aura", + "XP Tests (dbg)(1)" + ] + }, + "courgette_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "crypto_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "googleurl_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "gpu_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "installer_util_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "interactive_ui_tests": { + "builders": [ + "XP Tests (1)", + "Interactive Tests (dbg)", + "Vista Tests (1)", + "Win7 Tests (1)", + "Win Aura" + ] + }, + "ipc_tests": { + "builders": [ + "Win7 Tests (dbg)(1)", + "XP Tests (3)", + "Vista Tests (3)", + "Win7 Tests (3)", + "XP Tests (dbg)(1)" + ] + }, + "jingle_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "media_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "mini_installer_test": { + "builders": [ + "XP Tests (1)", + "Vista Tests (1)", + "Win7 Tests (1)" + ] + }, + "net_unittests": { + "builders": [ + "Win7 Tests (2)", + "XP Tests (2)", + "XP Tests (dbg)(2)", + "Win7 Tests (dbg)(2)", + "Vista Tests (2)" + ] + }, + "ppapi_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "printing_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "remoting_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + }, + "sbox_integration_tests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(3)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(3)" + ] + }, + "sbox_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(3)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(3)" + ] + }, + "sbox_validation_tests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(3)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(3)" + ] + }, + "sql_unittests": { + "builders": [ + "Win7 Tests (dbg)(1)", + "XP Tests (3)", + "Vista Tests (3)", + "Win7 Tests (3)", + "XP Tests (dbg)(1)" + ] + }, + "sync_integration_tests": { + "builders": [ + "Win7 Sync" + ] + }, + "sync_unit_tests": { + "builders": [ + "Win7 Tests (dbg)(1)", + "XP Tests (3)", + "Vista Tests (3)", + "Win7 Tests (3)", + "XP Tests (dbg)(1)" + ] + }, + "ui_unittests": { + "builders": [ + "Win7 Tests (dbg)(1)", + "XP Tests (3)", + "Vista Tests (3)", + "Win7 Tests (3)", + "XP Tests (dbg)(1)" + ] + }, + "unit_tests": { + "builders": [ + "Win7 Tests (dbg)(1)", + "XP Tests (3)", + "Vista Tests (3)", + "Win7 Tests (3)", + "Win Aura", + "XP Tests (dbg)(1)" + ] + }, + "views_unittests": { + "builders": [ + "Win7 Tests (dbg)(1)", + "XP Tests (3)", + "Vista Tests (3)", + "Win7 Tests (3)", + "Win Aura", + "XP Tests (dbg)(1)" + ] + }, + "webkit_compositor_bindings_unittests": { + "builders": [ + "XP Tests (1)", + "Win7 Tests (dbg)(1)", + "Vista Tests (1)", + "Win7 Tests (1)", + "XP Tests (dbg)(1)" + ] + } + }, + "url": "http://build.chromium.org/p/chromium.win" + }, + { + "name": "ChromiumMac", + "tests": { + "base_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "iOS Simulator (dbg)", + "Mac 10.7 Tests (dbg)(3)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(3)" + ] + }, + "browser_tests": { + "builders": [ + "Mac10.6 Tests (2)", + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "Mac10.6 Tests (3)", + "Mac 10.7 Tests (dbg)(3)", + "Mac 10.7 Tests (dbg)(2)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(4)", + "Mac10.7 Tests (2)", + "Mac 10.7 Tests (dbg)(4)", + "Mac 10.6 Tests (dbg)(2)", + "Mac 10.6 Tests (dbg)(3)", + "Mac10.7 Tests (3)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "cacheinvalidation_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "cc_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "content_browsertests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "content_unittests": { + "builders": [ + "Mac10.6 Tests (2)", + "Mac 10.6 Tests (dbg)(4)", + "Mac10.7 Tests (2)", + "Mac 10.7 Tests (dbg)(4)" + ] + }, + "crypto_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "iOS Simulator (dbg)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "googleurl_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "iOS Simulator (dbg)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "gpu_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "interactive_ui_tests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(3)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(3)" + ] + }, + "ipc_tests": { + "builders": [ + "Mac10.6 Tests (2)", + "Mac 10.6 Tests (dbg)(4)", + "Mac10.7 Tests (2)", + "Mac 10.7 Tests (dbg)(4)" + ] + }, + "jingle_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "media_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(2)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(2)" + ] + }, + "net_unittests": { + "builders": [ + "Mac10.6 Tests (3)", + "Mac 10.7 Tests (dbg)(2)", + "Mac 10.6 Tests (dbg)(2)", + "Mac10.7 Tests (3)" + ] + }, + "ppapi_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "printing_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "remoting_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + }, + "sql_unittests": { + "builders": [ + "Mac10.6 Tests (2)", + "iOS Simulator (dbg)", + "Mac 10.6 Tests (dbg)(4)", + "Mac10.7 Tests (2)", + "Mac 10.7 Tests (dbg)(4)" + ] + }, + "sync_integration_tests": { + "builders": [ + "Mac10.6 Sync" + ] + }, + "sync_unit_tests": { + "builders": [ + "Mac10.6 Tests (2)", + "Mac 10.6 Tests (dbg)(4)", + "Mac10.7 Tests (2)", + "Mac 10.7 Tests (dbg)(4)" + ] + }, + "ui_unittests": { + "builders": [ + "Mac10.6 Tests (2)", + "Mac 10.6 Tests (dbg)(4)", + "Mac10.7 Tests (2)", + "Mac 10.7 Tests (dbg)(4)" + ] + }, + "unit_tests": { + "builders": [ + "Mac10.6 Tests (2)", + "Mac 10.6 Tests (dbg)(4)", + "Mac10.7 Tests (2)", + "Mac 10.7 Tests (dbg)(4)" + ] + }, + "webkit_compositor_bindings_unittests": { + "builders": [ + "Mac10.7 Tests (1)", + "Mac 10.7 Tests (dbg)(1)", + "Mac10.6 Tests (1)", + "Mac 10.6 Tests (dbg)(1)" + ] + } + }, + "url": "http://build.chromium.org/p/chromium.mac" + }, + { + "name": "ChromiumLinux", + "tests": { + "Instrumentation tests: Smoke, SmallTest, MediumTest, LargeTest - ChromiumTestShellTest": { + "builders": [ + "Android Tests (dbg)" + ] + }, + "Instrumentation tests: Smoke, SmallTest, MediumTest, LargeTest - ContentShellTest": { + "builders": [ + "Android Tests (dbg)" + ] + }, + "aura_unittests": { + "builders": [ + "Linux (aura)" + ] + }, + "base_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux (Precise)", + "Linux Clang (dbg)", + "Android Tests (dbg)", + "Linux (aura)" + ] + }, + "browser_tests": { + "builders": [ + "Linux Tests (dbg)(1)", + "Linux Tests x64", + "Linux (Precise)" + ] + }, + "cacheinvalidation_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux (aura)" + ] + }, + "cc_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Android Tests (dbg)" + ] + }, + "compositor_unittests": { + "builders": [ + "Linux (aura)" + ] + }, + "content_browsertests": { + "builders": [ + "Linux Tests (dbg)(1)", + "Linux Tests x64", + "Linux (Precise)", + "Linux (aura)" + ] + }, + "content_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux Clang (dbg)", + "Android Tests (dbg)", + "Linux (aura)" + ] + }, + "crypto_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux Clang (dbg)", + "Linux (aura)" + ] + }, + "dbus_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64" + ] + }, + "device_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux Clang (dbg)", + "Linux (aura)" + ] + }, + "googleurl_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux (aura)" + ] + }, + "gpu_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Android Tests (dbg)", + "Linux (aura)" + ] + }, + "interactive_ui_tests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64" + ] + }, + "ipc_tests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux Clang (dbg)", + "Android Tests (dbg)", + "Linux (aura)" + ] + }, + "jingle_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux (aura)" + ] + }, + "media_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Android Tests (dbg)", + "Linux (aura)" + ] + }, + "net_unittests": { + "builders": [ + "Linux Tests (dbg)(1)", + "Linux Tests x64", + "Android Tests (dbg)", + "Linux (aura)" + ] + }, + "ppapi_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux (aura)" + ] + }, + "printing_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux (aura)" + ] + }, + "remoting_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux (aura)" + ] + }, + "sandbox_linux_unittests": { + "builders": [ + "Linux Tests x64", + "Linux (Precise)" + ] + }, + "sql_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux Clang (dbg)", + "Android Tests (dbg)", + "Linux (aura)" + ] + }, + "sync_integration_tests": { + "builders": [ + "Linux Sync" + ] + }, + "sync_unit_tests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux Clang (dbg)", + "Android Tests (dbg)", + "Linux (aura)" + ] + }, + "ui_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux Clang (dbg)", + "Android Tests (dbg)", + "Linux (aura)" + ] + }, + "unit_tests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Linux Clang (dbg)", + "Android Tests (dbg)", + "Linux (aura)" + ] + }, + "views_unittests": { + "builders": [ + "Linux (aura)" + ] + }, + "webkit_compositor_bindings_unittests": { + "builders": [ + "Linux Tests (dbg)(2)", + "Linux Tests x64", + "Android Tests (dbg)" + ] + } + }, + "url": "http://build.chromium.org/p/chromium.linux" + }, + { + "name": "ChromiumChromiumOS", + "tests": { + "ash_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "aura_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "base_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "browser_tests": { + "builders": [ + "Linux ChromiumOS Tests (2)", + "Linux ChromiumOS Tests (dbg)(2)" + ] + }, + "cacheinvalidation_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "compositor_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "content_browsertests": { + "builders": [ + "Linux ChromiumOS Tests (2)", + "Linux ChromiumOS Tests (dbg)(2)" + ] + }, + "content_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "crypto_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "dbus_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "googleurl_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "gpu_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "interactive_ui_tests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(3)", + "Linux ChromiumOS Tests (2)" + ] + }, + "ipc_tests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "jingle_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "media_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "net_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "ppapi_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "printing_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "remoting_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "sql_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "sync_unit_tests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "ui_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "unit_tests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + }, + "views_unittests": { + "builders": [ + "Linux ChromiumOS Tests (dbg)(1)", + "Linux ChromiumOS Tests (1)" + ] + } + }, + "url": "http://build.chromium.org/p/chromium.chromiumos" + }, + { + "name": "ChromiumGPU", + "tests": { + "gl_tests": { + "builders": [ + "Win7 Debug (NVIDIA)", + "Mac Release (Intel)", + "Mac Debug (Intel)", + "Win7 Release (NVIDIA)", + "Linux Debug (NVIDIA)", + "Linux Release (NVIDIA)" + ] + }, + "gles2_conform_test": { + "builders": [ + "Win7 Debug (NVIDIA)", + "Mac Release (Intel)", + "Mac Debug (Intel)", + "Win7 Release (NVIDIA)", + "Linux Debug (NVIDIA)", + "Linux Release (NVIDIA)" + ] + }, + "gpu_frame_rate_test": { + "builders": [ + "Mac Release (Intel)", + "Win7 Release (NVIDIA)", + "Linux Release (NVIDIA)" + ] + }, + "gpu_latency_tests": { + "builders": [ + "Mac Release (Intel)", + "Win7 Release (NVIDIA)", + "Linux Release (NVIDIA)" + ] + }, + "gpu_tests": { + "builders": [ + "Win7 Debug (NVIDIA)", + "Mac Release (Intel)", + "Mac Debug (Intel)", + "Win7 Release (NVIDIA)", + "Linux Debug (NVIDIA)", + "Linux Release (NVIDIA)" + ] + }, + "gpu_throughput_tests": { + "builders": [ + "Mac Release (Intel)", + "Win7 Release (NVIDIA)", + "Linux Release (NVIDIA)" + ] + } + }, + "url": "http://build.chromium.org/p/chromium.gpu" + }, + { + "name": "ChromiumGPUFYI", + "tests": { + "content_unittests": { + "builders": [ + "Linux Audio", + "Win7 Audio" + ] + }, + "gl_tests": { + "builders": [ + "Mac Release (ATI)", + "WinXP Debug (NVIDIA)", + "Linux Release (ATI)", + "Mac Retina Release", + "Win7 Release (Intel)", + "Win7 Release (ATI)", + "Linux Release (Intel)", + "Mac Retina Debug", + "WinXP Release (NVIDIA)" + ] + }, + "gles2_conform_test": { + "builders": [ + "Mac Release (ATI)", + "WinXP Debug (NVIDIA)", + "Linux Release (ATI)", + "Mac Retina Release", + "Win7 Release (Intel)", + "Win7 Release (ATI)", + "Linux Release (Intel)", + "Mac Retina Debug", + "WinXP Release (NVIDIA)" + ] + }, + "gpu_frame_rate_test": { + "builders": [ + "Mac Release (ATI)", + "Linux Release (ATI)", + "Mac Retina Release", + "Win7 Release (Intel)", + "Win7 Release (ATI)", + "Linux Release (Intel)", + "WinXP Release (NVIDIA)" + ] + }, + "gpu_latency_tests": { + "builders": [ + "Mac Release (ATI)", + "Linux Release (ATI)", + "Mac Retina Release", + "Win7 Release (Intel)", + "Win7 Release (ATI)", + "Linux Release (Intel)", + "WinXP Release (NVIDIA)" + ] + }, + "gpu_tests": { + "builders": [ + "Mac Release (ATI)", + "WinXP Debug (NVIDIA)", + "Linux Release (ATI)", + "Mac Retina Release", + "Win7 Release (Intel)", + "Win7 Release (ATI)", + "Linux Release (Intel)", + "Mac Retina Debug", + "WinXP Release (NVIDIA)" + ] + }, + "gpu_throughput_tests": { + "builders": [ + "Mac Release (ATI)", + "Linux Release (ATI)", + "Mac Retina Release", + "Win7 Release (Intel)", + "Win7 Release (ATI)", + "Linux Release (Intel)", + "WinXP Release (NVIDIA)" + ] + }, + "media_unittests": { + "builders": [ + "Linux Audio", + "Win7 Audio" + ] + } + }, + "url": "http://build.chromium.org/p/chromium.gpu.fyi" + }, + { + "name": "ChromiumPerfAv", + "tests": { + "layout-tests": { + "builders": [ + "AV Win7", + "AV Linux" + ] + }, + "media_tests_av_perf": { + "builders": [ + "AV Win7", + "AV Linux" + ] + } + }, + "url": "http://build.chromium.org/p/chromium.perf_av" + }, + { + "name": "ChromiumWebkit", + "tests": { + "base_unittests": { + "builders": [ + "Android Tests (dbg)" + ] + }, + "browser_tests": { + "builders": [ + "Win7 (dbg)", + "Linux Tests", + "Mac10.6 Tests", + "Mac10.8 Tests" + ] + }, + "cc_unittests": { + "builders": [ + "Android Tests (dbg)" + ] + }, + "chrome_frame_net_tests": { + "builders": [ + "Chrome Frame Tests" + ] + }, + "chrome_frame_tests": { + "builders": [ + "Chrome Frame Tests" + ] + }, + "chrome_frame_unittests": { + "builders": [ + "Chrome Frame Tests" + ] + }, + "content_browsertests": { + "builders": [ + "Win7 (dbg)", + "Linux Tests", + "Mac10.6 Tests", + "Mac10.8 Tests" + ] + }, + "content_unittests": { + "builders": [ + "Win7 (dbg)", + "Vista Tests", + "Linux Tests", + "Mac10.6 Tests", + "Android Tests (dbg)", + "Mac10.8 Tests" + ] + }, + "dromaeo_domcoreattr_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_domcoremodify_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_domcorequery_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_domcoretraverse_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_jslibattrjquery_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_jslibattrprototype_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_jslibeventjquery_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_jslibeventprototype_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_jslibmodifyjquery_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_jslibmodifyprototype_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_jslibstylejquery_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_jslibstyleprototype_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_jslibtraversejquery_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "dromaeo_jslibtraverseprototype_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "gl_tests": { + "builders": [ + "GPU Win7 (NVIDIA)", + "GPU Linux (NVIDIA)", + "GPU Mac10.7", + "GPU Win7 (dbg) (NVIDIA)", + "GPU Mac10.7 (dbg)", + "GPU Linux (dbg) (NVIDIA)" + ] + }, + "gpu_frame_rate_test": { + "builders": [ + "GPU Win7 (NVIDIA)", + "GPU Linux (NVIDIA)", + "GPU Mac10.7" + ] + }, + "gpu_latency_tests": { + "builders": [ + "GPU Win7 (NVIDIA)", + "GPU Linux (NVIDIA)", + "GPU Mac10.7" + ] + }, + "gpu_tests": { + "builders": [ + "GPU Win7 (NVIDIA)", + "GPU Linux (NVIDIA)", + "GPU Mac10.7", + "GPU Win7 (dbg) (NVIDIA)", + "GPU Mac10.7 (dbg)", + "GPU Linux (dbg) (NVIDIA)" + ] + }, + "gpu_throughput_tests": { + "builders": [ + "GPU Win7 (NVIDIA)", + "GPU Linux (NVIDIA)", + "GPU Mac10.7" + ] + }, + "gpu_unittests": { + "builders": [ + "Android Tests (dbg)" + ] + }, + "installer_util_unittests": { + "builders": [ + "Vista Tests" + ] + }, + "interactive_ui_tests": { + "builders": [ + "Win7 (dbg)", + "Linux Tests", + "Mac10.6 Tests", + "Mac10.8 Tests" + ] + }, + "ipc_tests": { + "builders": [ + "Win7 (dbg)", + "Vista Tests", + "Linux Tests", + "Mac10.6 Tests", + "Android Tests (dbg)", + "Mac10.8 Tests" + ] + }, + "layout-tests": { + "builders": [ + "WebKit Linux 32", + "WebKit Win7", + "WebKit Linux ASAN", + "WebKit Win7 (dbg)(2)", + "WebKit (Content Shell) Linux", + "WebKit (Content Shell) Win", + "WebKit Mac10.7 (dbg)", + "WebKit Mac10.6 (dbg)", + "WebKit Linux", + "WebKit Linux (dbg)", + "WebKit Mac10.6", + "WebKit Mac10.7", + "WebKit Linux (deps)", + "WebKit Mac10.8", + "WebKit Mac10.6 (deps)", + "WebKit (Content Shell) Mac10.6", + "WebKit Win7 (dbg)(1)", + "WebKit XP (deps)", + "WebKit XP" + ] + }, + "media_unittests": { + "builders": [ + "Android Tests (dbg)" + ] + }, + "memory test: test_shell": { + "builders": [ + "Linux Valgrind" + ] + }, + "memory_test": { + "builders": [ + "Mac10.6 Perf" + ] + }, + "mini_installer_test": { + "builders": [ + "Vista Tests" + ] + }, + "net_unittests": { + "builders": [ + "Android Tests (dbg)" + ] + }, + "new_tab_ui_cold_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "new_tab_ui_warm_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "sql_unittests": { + "builders": [ + "Win7 (dbg)", + "Vista Tests", + "Linux Tests", + "Mac10.6 Tests", + "Android Tests (dbg)", + "Mac10.8 Tests" + ] + }, + "startup_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "sunspider_test": { + "builders": [ + "Win7 Perf", + "Mac10.6 Perf", + "Linux Perf" + ] + }, + "sync_unit_tests": { + "builders": [ + "Win7 (dbg)", + "Vista Tests", + "Linux Tests", + "Mac10.6 Tests", + "Android Tests (dbg)", + "Mac10.8 Tests" + ] + }, + "tab_switching_test": { + "builders": [ + "Mac10.6 Perf" + ] + }, + "test_shell_tests": { + "builders": [ + "WebKit Linux 32", + "WebKit Win7", + "WebKit Mac10.7 (dbg)", + "WebKit Mac10.6 (dbg)", + "WebKit Linux", + "WebKit Linux (dbg)", + "WebKit Mac10.6", + "WebKit Mac10.7", + "WebKit Linux (deps)", + "WebKit Mac10.8", + "WebKit Mac10.6 (deps)", + "WebKit Win7 (dbg)(1)", + "WebKit XP (deps)", + "WebKit XP" + ] + }, + "ui_unittests": { + "builders": [ + "Win7 (dbg)", + "Vista Tests", + "Linux Tests", + "Mac10.6 Tests", + "Android Tests (dbg)", + "Mac10.8 Tests" + ] + }, + "unit_tests": { + "builders": [ + "Win7 (dbg)", + "Vista Tests", + "Linux Tests", + "Mac10.6 Tests", + "Android Tests (dbg)", + "Mac10.8 Tests" + ] + }, + "v8_benchmark_test": { + "builders": [ + "Mac10.6 Perf" + ] + }, + "views_unittests": { + "builders": [ + "Win7 (dbg)", + "Vista Tests" + ] + }, + "webkit_compositor_bindings_unittests": { + "builders": [ + "Android Tests (dbg)" + ] + }, + "webkit_unit_tests": { + "builders": [ + "WebKit Linux 32", + "WebKit Win7", + "WebKit Android (GalaxyNexus)", + "WebKit Mac10.7 (dbg)", + "WebKit Mac10.6 (dbg)", + "WebKit Linux", + "WebKit Linux (dbg)", + "WebKit Mac10.6", + "WebKit Mac10.7", + "WebKit Linux (deps)", + "WebKit Mac10.8", + "WebKit Mac10.6 (deps)", + "WebKit Win7 (dbg)(1)", + "WebKit XP (deps)", + "WebKit XP" + ] + } + }, + "url": "http://build.chromium.org/p/chromium.webkit" + }, + { + "name": "webkit.org", + "tests": { + "layout-tests": { + "builders": [ + "Apple Lion (Leaks)", + "Apple Lion Debug WK1 (Tests)", + "Apple Lion Debug WK2 (Tests)", + "Apple Lion Release WK1 (Tests)", + "Apple Lion Release WK2 (Tests)", + "Apple MountainLion (Leaks)", + "Apple MountainLion Debug WK1 (Tests)", + "Apple MountainLion Debug WK2 (Tests)", + "Apple MountainLion Release WK1 (Tests)", + "Apple MountainLion Release WK2 (Tests)", + "Apple Win 7 Release (Tests)", + "Apple Win XP Debug (Tests)", + "Chromium Android Release (Tests)", + "Chromium Linux Release (Tests)", + "Chromium Mac Release (Tests)", + "Chromium Win Release (Tests)", + "EFL Linux 64-bit Debug WK2", + "EFL Linux 64-bit Release", + "EFL Linux 64-bit Release WK2", + "GTK Linux 32-bit Release", + "GTK Linux 64-bit Debug", + "GTK Linux 64-bit Release", + "GTK Linux 64-bit Release WK2 (Tests)", + "Qt Linux Release", + "WinCairo Release" + ] + } + }, + "url": "http://build.webkit.org" + } +]); diff --git a/Tools/TestResultServer/static-dashboards/builders_unittests.js b/Tools/TestResultServer/static-dashboards/builders_unittests.js new file mode 100644 index 000000000..29c02f151 --- /dev/null +++ b/Tools/TestResultServer/static-dashboards/builders_unittests.js @@ -0,0 +1,41 @@ +// Copyright (C) 2012 Google Inc. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +test('loading steps', 4, function() { + var tests = {} + var baseUrl = 'http://dummyurl'; + var name = 'dummyname'; + var master = new builders.BuilderMaster(name, baseUrl, tests); + + var builder = 'dummybuilder'; + var buildNumber = 12345; + equal(master.logPath(builder, buildNumber), baseUrl + '/builders/' + builder + '/builds/' + buildNumber); + equal(master.builderJsonPath(), baseUrl + '/json/builders'); + equal(master.tests, tests); + equal(master.name, name); +}) diff --git a/Tools/TestResultServer/static-dashboards/dashboard_base.js b/Tools/TestResultServer/static-dashboards/dashboard_base.js index 6ec0c8e42..f685ad6f6 100644 --- a/Tools/TestResultServer/static-dashboards/dashboard_base.js +++ b/Tools/TestResultServer/static-dashboards/dashboard_base.js @@ -425,11 +425,6 @@ function currentBuilderGroup() return currentBuilderGroupCategory()[g_crossDashboardState.group] } -function builderMaster(builderName) -{ - return BUILDER_TO_MASTER[builderName]; -} - function isTipOfTreeWebKitBuilder() { return currentBuilderGroup().isToTWebKit; diff --git a/Tools/TestResultServer/static-dashboards/flakiness_dashboard.js b/Tools/TestResultServer/static-dashboards/flakiness_dashboard.js index 7589e3424..d44e3e58e 100644 --- a/Tools/TestResultServer/static-dashboards/flakiness_dashboard.js +++ b/Tools/TestResultServer/static-dashboards/flakiness_dashboard.js @@ -1223,7 +1223,7 @@ function showPopupForBuild(e, builder, index, opt_testName) 'WebKit') + '</li>'; - if (master == WEBKIT_BUILDER_MASTER) { + if (master.name == WEBKIT_BUILDER_MASTER) { var revision = g_resultsByBuilder[builder].webkitRevision[index]; html += '<li><span class=link onclick="setQueryParameter(\'revision\',' + revision + ')">Show results for WebKit r' + revision + @@ -1291,7 +1291,7 @@ function htmlForTestResults(test) var extraClassNames = ''; var webkitRevision = g_resultsByBuilder[builder].webkitRevision; var isWebkitMerge = webkitRevision[i + 1] && webkitRevision[i] != webkitRevision[i + 1]; - if (isWebkitMerge && master != WEBKIT_BUILDER_MASTER) + if (isWebkitMerge && master.name != WEBKIT_BUILDER_MASTER) extraClassNames += ' merge'; html += '<td title="' + (resultString || 'NO DATA') + '. Click for more info." class="results ' + currentResult + @@ -1821,7 +1821,7 @@ function htmlForIndividualTestOnAllBuildersWithResultsLinks(test) if (isLayoutTestResults() || isGPUTestResults()) { if (isLayoutTestResults()) html += ' | ' + linkHTMLToToggleState('showLargeExpectations', 'large thumbnails'); - if (testResults && builderMaster(testResults[0].builder) == WEBKIT_BUILDER_MASTER) { + if (testResults && currentBuilderGroup().master().name == WEBKIT_BUILDER_MASTER) { var revision = g_currentState.revision || ''; html += '<form onsubmit="setQueryParameter(\'revision\', revision.value);' + 'return false;">Show results for WebKit revision: ' + @@ -2256,7 +2256,7 @@ function loadExpectationsLayoutTests(test, expectationsContainer) revisionContainer.textContent = "Showing results for: " expectationsContainer.appendChild(revisionContainer); for (var builder in g_builders) { - if (builderMaster(builder) == WEBKIT_BUILDER_MASTER) { + if (builderMaster(builder).name == WEBKIT_BUILDER_MASTER) { var latestRevision = g_currentState.revision || g_resultsByBuilder[builder].webkitRevision[0]; var buildInfo = buildInfoForRevision(builder, latestRevision); var revisionInfo = document.createElement('div'); @@ -2274,7 +2274,7 @@ function loadExpectationsLayoutTests(test, expectationsContainer) for (var builder in g_builders) { var actualResultsBase; - if (builderMaster(builder) == WEBKIT_BUILDER_MASTER) { + if (builderMaster(builder).name == WEBKIT_BUILDER_MASTER) { var latestRevision = g_currentState.revision || g_resultsByBuilder[builder].webkitRevision[0]; var buildInfo = buildInfoForRevision(builder, latestRevision); actualResultsBase = 'http://build.webkit.org/results/' + builder + diff --git a/Tools/TestResultServer/static-dashboards/flakiness_dashboard_tests.css b/Tools/TestResultServer/static-dashboards/flakiness_dashboard_tests.css index f83a69af1..6165bcdff 100644 --- a/Tools/TestResultServer/static-dashboards/flakiness_dashboard_tests.css +++ b/Tools/TestResultServer/static-dashboards/flakiness_dashboard_tests.css @@ -104,7 +104,7 @@ border: 1px solid grey; } .P { - background-color: #8fdf5f; + background-color: #3f3; } .N { background-color: #fff; @@ -113,7 +113,7 @@ background-color: lightgray; } .C { - background-color: #ffc343; + background-color: #c90; } .T { background-color: #fffc6c; diff --git a/Tools/TestResultServer/static-dashboards/flakiness_dashboard_unittests.js b/Tools/TestResultServer/static-dashboards/flakiness_dashboard_unittests.js index 597c62e2a..ac264b407 100644 --- a/Tools/TestResultServer/static-dashboards/flakiness_dashboard_unittests.js +++ b/Tools/TestResultServer/static-dashboards/flakiness_dashboard_unittests.js @@ -37,8 +37,23 @@ function resetGlobals() g_allTestsTrie = null; g_currentState = {}; g_crossDashboardState = {}; + g_testToResultsMap = {}; + for (var key in g_defaultCrossDashboardStateValues) g_crossDashboardState[key] = g_defaultCrossDashboardStateValues[key]; + + LOAD_BUILDBOT_DATA([{ + name: 'ChromiumWebkit', + url: 'dummyurl', + tests: {'layout-tests': {'builders': ['WebKit Linux', 'WebKit Linux (dbg)', 'WebKit Mac10.7', 'WebKit Win']}} + }, + { + name: 'webkit.org', + url: 'dummyurl', + tests: {'layout-tests': {'builders': ['Apple SnowLeopard Tests', 'Qt Linux Tests', 'Chromium Mac10.7 Tests', 'GTK Win']}} + }]); + for (var group in LAYOUT_TESTS_BUILDER_GROUPS) + LAYOUT_TESTS_BUILDER_GROUPS[group] = null; } function runExpectationsTest(builder, test, expectations, modifiers) @@ -371,9 +386,10 @@ test('htmlForIndividualTestOnAllBuildersWithResultsLinksNonexistant', 1, functio test('htmlForIndividualTestOnAllBuildersWithResultsLinks', 1, function() { resetGlobals(); + loadBuildersList('@ToT - chromium.org', 'layout-tests'); + + var builderName = 'WebKit Linux'; var test = 'dummytest.html'; - var builderName = 'dummyBuilder'; - BUILDER_TO_MASTER[builderName] = CHROMIUM_BUILDER_MASTER; g_testToResultsMap[test] = [createResultsObjectForTest(test, builderName)]; equal(htmlForIndividualTestOnAllBuildersWithResultsLinks(test), @@ -389,8 +405,7 @@ test('htmlForIndividualTestOnAllBuildersWithResultsLinks', 1, function() { '</table>' + '<div>The following builders either don\'t run this test (e.g. it\'s skipped) or all runs passed:</div>' + '<div class=skipped-builder-list>' + - '<div class=skipped-builder>WebKit Linux</div><div class=skipped-builder>WebKit Linux (dbg)</div>' + - '<div class=skipped-builder>WebKit Mac10.7</div><div class=skipped-builder>WebKit Win</div>' + + '<div class=skipped-builder>WebKit Linux (dbg)</div><div class=skipped-builder>WebKit Mac10.7</div><div class=skipped-builder>WebKit Win</div>' + '</div>' + '<div class=expectations test=dummytest.html>' + '<div><span class=link onclick="setQueryParameter(\'showExpectations\', true)">Show results</span> | ' + @@ -401,9 +416,11 @@ test('htmlForIndividualTestOnAllBuildersWithResultsLinks', 1, function() { test('htmlForIndividualTestOnAllBuildersWithResultsLinksWebkitMaster', 1, function() { resetGlobals(); + g_crossDashboardState.group = '@ToT - webkit.org'; + loadBuildersList('@ToT - webkit.org', 'layout-tests'); + + var builderName = 'Apple SnowLeopard Tests'; var test = 'dummytest.html'; - var builderName = 'dummyBuilder'; - BUILDER_TO_MASTER[builderName] = WEBKIT_BUILDER_MASTER; g_testToResultsMap[test] = [createResultsObjectForTest(test, builderName)]; equal(htmlForIndividualTestOnAllBuildersWithResultsLinks(test), @@ -419,8 +436,7 @@ test('htmlForIndividualTestOnAllBuildersWithResultsLinksWebkitMaster', 1, functi '</table>' + '<div>The following builders either don\'t run this test (e.g. it\'s skipped) or all runs passed:</div>' + '<div class=skipped-builder-list>' + - '<div class=skipped-builder>WebKit Linux</div><div class=skipped-builder>WebKit Linux (dbg)</div>' + - '<div class=skipped-builder>WebKit Mac10.7</div><div class=skipped-builder>WebKit Win</div>' + + '<div class=skipped-builder>Qt Linux Tests</div><div class=skipped-builder>Chromium Mac10.7 Tests</div><div class=skipped-builder>GTK Win</div>' + '</div>' + '<div class=expectations test=dummytest.html>' + '<div><span class=link onclick="setQueryParameter(\'showExpectations\', true)">Show results</span> | ' + @@ -509,93 +525,23 @@ test('baseTest', 2, function() { }); // FIXME: Create builders_tests.js and move this there. -test('generateChromiumDepsFyiGpuBuildersFromBuilderList', 1, function() { - var builderList = ["Linux Audio", "Linux Release (ATI)", "Linux Release (Intel)", "Mac Release (ATI)", "Win7 Audio", "Win7 Release (ATI)", "Win7 Release (Intel)", "WinXP Debug (NVIDIA)", "WinXP Release (NVIDIA)"]; - var expectedBuilders = [["Linux Release (ATI)", 2], ["Linux Release (Intel)"], ["Mac Release (ATI)"], ["Win7 Release (ATI)"], ["Win7 Release (Intel)"], ["WinXP Debug (NVIDIA)"], ["WinXP Release (NVIDIA)"] ]; - deepEqual(generateBuildersFromBuilderList(builderList, isChromiumDepsFyiGpuTestRunner), expectedBuilders); -}); - -test('generateChromiumTipOfTreeGpuBuildersFromBuilderList', 1, function() { - var builderList = ["Chrome Frame Tests", "GPU Linux (NVIDIA)", "GPU Linux (dbg) (NVIDIA)", "GPU Mac", "GPU Mac (dbg)", "GPU Win7 (NVIDIA)", "GPU Win7 (dbg) (NVIDIA)", "Linux Perf", - "Linux Tests", "Linux Valgrind", "Mac Builder (dbg)", "Mac10.6 Perf", "Mac10.6 Tests", "Vista Perf", "Vista Tests", "WebKit Linux", "WebKit Linux ASAN", "WebKit Linux (dbg)", "WebKit Linux (deps)", - "WebKit Linux 32", "WebKit Mac Builder", "WebKit Mac Builder (dbg)", "WebKit Mac Builder (deps)", - "WebKit Mac10.6", "WebKit Mac10.6 (dbg)", "WebKit Mac10.6 (deps)", "WebKit Mac10.7", "WebKit Win", "WebKit Win (dbg)(1)", "WebKit Win (dbg)(2)", - "WebKit Win (deps)", "WebKit Win Builder", "WebKit Win Builder (dbg)", "WebKit Win Builder (deps)", "WebKit Win7", "Win (dbg)", "Win Builder"]; - var expectedBuilders = [["GPU Linux (NVIDIA)", 2], ["GPU Linux (dbg) (NVIDIA)"], ["GPU Mac"], ["GPU Mac (dbg)"], ["GPU Win7 (NVIDIA)"], ["GPU Win7 (dbg) (NVIDIA)"]]; - deepEqual(generateBuildersFromBuilderList(builderList, isChromiumTipOfTreeGpuTestRunner), expectedBuilders); -}); - -test('generateWebkitBuildersFromBuilderList', 1, function() { - var builderList = ["Chromium Android Release", "Chromium Linux Release", "Chromium Linux Release (Grid Layout)", "Chromium Linux Release (Perf)", "Chromium Linux Release (Tests)", - "Chromium Mac Release", "Chromium Mac Release (Perf)", "Chromium Mac Release (Tests)", "Chromium Win Release", "Chromium Win Release (Perf)", "Chromium Win Release (Tests)", - "EFL Linux Release", "GTK Linux 32-bit Release", "GTK Linux 64-bit Debug", "GTK Linux 64-bit Release", "Lion Debug (Build)", "Lion Debug (Tests)", "Lion Debug (WebKit2 Tests)", - "Lion Leaks", "Lion Release (Build)", "Lion Release (Perf)", "Lion Release (Tests)", "Lion Release (WebKit2 Tests)", "Qt Linux 64-bit Release (Perf)", - "Qt Linux 64-bit Release (WebKit2 Perf)", "Qt Linux ARMv7 Release", "Qt Linux MIPS Release", "Qt Linux Release", "Qt Linux Release minimal", "Qt Linux SH4 Release", - "Qt SnowLeopard Release", "Qt Windows 32-bit Debug", "Qt Windows 32-bit Release", "SnowLeopard Intel Debug (Build)", "SnowLeopard Intel Debug (Tests)", - "SnowLeopard Intel Debug (WebKit2 Tests)", "SnowLeopard Intel Release (Build)", "SnowLeopard Intel Release (Tests)", "SnowLeopard Intel Release (WebKit2 Tests)", - "WinCE Release (Build)", "WinCairo Release", "Windows 7 Release (Tests)", "Windows 7 Release (WebKit2 Tests)", "Windows Debug (Build)", "Windows Release (Build)", "Windows XP Debug (Tests)", - "EFL Linux 32-bit Release (Build)", "EFL Linux 64-bit Debug"]; - var expectedBuilders = [["Chromium Linux Release (Tests)", 2], ["Chromium Mac Release (Tests)"], ["EFL Linux Release"], ["GTK Linux 32-bit Release"], ["GTK Linux 64-bit Debug"], - ["GTK Linux 64-bit Release"], ["Lion Debug (Tests)"], ["Lion Debug (WebKit2 Tests)"], ["Lion Release (Tests)"], ["Lion Release (WebKit2 Tests)"], ["Qt Linux Release"], - ["SnowLeopard Intel Debug (Tests)"], ["SnowLeopard Intel Debug (WebKit2 Tests)"], ["SnowLeopard Intel Release (Tests)"], ["SnowLeopard Intel Release (WebKit2 Tests)"], ["EFL Linux 64-bit Debug"]]; - deepEqual(generateBuildersFromBuilderList(builderList, isWebkitTestRunner), expectedBuilders); -}); - -test('generateChromiumWebkitTipOfTreeBuildersFromBuilderList', 1, function() { - var builderList = ["Chrome Frame Tests", "GPU Linux (NVIDIA)", "GPU Linux (dbg) (NVIDIA)", "GPU Mac", "GPU Mac (dbg)", "GPU Win7 (NVIDIA)", "GPU Win7 (dbg) (NVIDIA)", "Linux Perf", "Linux Tests", - "Linux Valgrind", "Mac Builder (dbg)", "Mac10.6 Perf", "Mac10.6 Tests", "Vista Perf", "Vista Tests", "WebKit Linux", "WebKit Linux ASAN", "WebKit Linux (dbg)", "WebKit Linux (deps)", "WebKit Linux 32", - "WebKit Mac Builder", "WebKit Mac Builder (dbg)", "WebKit Mac Builder (deps)", "WebKit Mac10.6", "WebKit Mac10.6 (dbg)", - "WebKit Mac10.6 (deps)", "WebKit Mac10.7", "WebKit Win", "WebKit Win (dbg)(1)", "WebKit Win (dbg)(2)", "WebKit Win (deps)", "WebKit Win Builder", "WebKit Win Builder (dbg)", - "WebKit Win Builder (deps)", "WebKit Win7", "Win (dbg)", "Win Builder", - "Linux (Content Shell)"]; - var expectedBuilders = [["WebKit Linux", 2], ["WebKit Linux (dbg)"], ["WebKit Linux 32"], ["WebKit Mac10.6"], - ["WebKit Mac10.6 (dbg)"], ["WebKit Mac10.7"], ["WebKit Win"], ["WebKit Win (dbg)(1)"], ["WebKit Win (dbg)(2)"], ["WebKit Win7"]]; - deepEqual(generateBuildersFromBuilderList(builderList, isChromiumWebkitTipOfTreeTestRunner), expectedBuilders); + +test('isChromiumWebkitTipOfTreeTestRunner', 1, function() { + var builderList = ["WebKit Linux", "WebKit Linux (dbg)", "WebKit Linux 32", "WebKit Mac10.6", "WebKit Mac10.6 (dbg)", + "WebKit Mac10.6 (deps)", "WebKit Mac10.7", "WebKit Win", "WebKit Win (dbg)(1)", "WebKit Win (dbg)(2)", "WebKit Win (deps)", + "WebKit Win7", "Linux (Content Shell)"]; + var expectedBuilders = ["WebKit Linux", "WebKit Linux (dbg)", "WebKit Linux 32", "WebKit Mac10.6", + "WebKit Mac10.6 (dbg)", "WebKit Mac10.7", "WebKit Win", "WebKit Win (dbg)(1)", "WebKit Win (dbg)(2)", "WebKit Win7"]; + deepEqual(builderList.filter(isChromiumWebkitTipOfTreeTestRunner), expectedBuilders); }); -test('generateChromiumWebkitDepsBuildersFromBuilderList', 1, function() { +test('isChromiumWebkitDepsTestRunner', 1, function() { var builderList = ["Chrome Frame Tests", "GPU Linux (NVIDIA)", "GPU Linux (dbg) (NVIDIA)", "GPU Mac", "GPU Mac (dbg)", "GPU Win7 (NVIDIA)", "GPU Win7 (dbg) (NVIDIA)", "Linux Perf", "Linux Tests", "Linux Valgrind", "Mac Builder (dbg)", "Mac10.6 Perf", "Mac10.6 Tests", "Vista Perf", "Vista Tests", "WebKit Linux", "WebKit Linux ASAN", "WebKit Linux (dbg)", "WebKit Linux (deps)", "WebKit Linux 32", - "WebKit Mac Builder", "WebKit Mac Builder (dbg)", "WebKit Mac Builder (deps)", "WebKit Mac10.6", "WebKit Mac10.6 (dbg)", - "WebKit Mac10.6 (deps)", "WebKit Mac10.7", "WebKit Win", "WebKit Win (dbg)(1)", "WebKit Win (dbg)(2)", "WebKit Win (deps)", "WebKit Win Builder", "WebKit Win Builder (dbg)", - "WebKit Win Builder (deps)", "WebKit Win7", "Win (dbg)", "Win Builder"]; - var expectedBuilders = [["WebKit Linux (deps)", 2], ["WebKit Mac10.6 (deps)"], ["WebKit Win (deps)"]]; - deepEqual(generateBuildersFromBuilderList(builderList, isChromiumWebkitDepsTestRunner), expectedBuilders); -}); - -test('generateChromiumDepsGTestBuildersFromBuilderList', 1, function() { - var builderList = ["Android Builder", "Chrome Frame Tests (ie6)", "Chrome Frame Tests (ie7)", "Chrome Frame Tests (ie8)", "Interactive Tests (dbg)", "Linux", "Linux Builder (dbg)", - "Linux Builder (dbg)(shared)", "Linux Builder x64", "Linux Clang (dbg)", "Linux Sync", "Linux Tests (dbg)(1)", "Linux Tests (dbg)(2)", "Linux Tests (dbg)(shared)", "Linux Tests x64", - "Linux x64", "Mac", "Mac 10.6 Tests (dbg)(1)", "Mac 10.6 Tests (dbg)(2)", - "Mac 10.6 Tests (dbg)(3)", "Mac 10.6 Tests (dbg)(4)", "Mac Builder", "Mac Builder (dbg)", "Mac10.6 Sync", - "Mac10.6 Tests (1)", "Mac10.6 Tests (2)", "Mac10.6 Tests (3)", "NACL Tests", "NACL Tests (x64)", "Vista Tests (1)", "Vista Tests (2)", "Vista Tests (3)", "Win", "Win Aura", - "Win Builder", "Win Builder (dbg)", "Win Builder 2010 (dbg)", "Win7 Sync", "Win7 Tests (1)", "Win7 Tests (2)", "Win7 Tests (3)", "Win7 Tests (dbg)(1)", "Win7 Tests (dbg)(2)", - "Win7 Tests (dbg)(3)", "Win7 Tests (dbg)(4)", "Win7 Tests (dbg)(5)", "Win7 Tests (dbg)(6)", "XP Tests (1)", "XP Tests (2)", "XP Tests (3)", "XP Tests (dbg)(1)", "XP Tests (dbg)(2)", - "XP Tests (dbg)(3)", "XP Tests (dbg)(4)", "XP Tests (dbg)(5)", "XP Tests (dbg)(6)"]; - var expectedBuilders = [["Interactive Tests (dbg)", 2], ["Linux Sync"], ["Linux Tests (dbg)(1)"], ["Linux Tests (dbg)(2)"], ["Linux Tests (dbg)(shared)"], ["Linux Tests x64"], - ["Mac 10.6 Tests (dbg)(1)"], ["Mac 10.6 Tests (dbg)(2)"], ["Mac 10.6 Tests (dbg)(3)"], - ["Mac 10.6 Tests (dbg)(4)"], ["Mac10.6 Sync"], ["Mac10.6 Tests (1)"], ["Mac10.6 Tests (2)"], ["Mac10.6 Tests (3)"], ["NACL Tests"], - ["NACL Tests (x64)"], ["Vista Tests (1)"], ["Vista Tests (2)"], ["Vista Tests (3)"], ["Win7 Sync"], ["Win7 Tests (1)"], ["Win7 Tests (2)"], ["Win7 Tests (3)"], ["Win7 Tests (dbg)(1)"], - ["Win7 Tests (dbg)(2)"], ["Win7 Tests (dbg)(3)"], ["Win7 Tests (dbg)(4)"], ["Win7 Tests (dbg)(5)"], ["Win7 Tests (dbg)(6)"], ["XP Tests (1)"], ["XP Tests (2)"], ["XP Tests (3)"], - ["XP Tests (dbg)(1)"], ["XP Tests (dbg)(2)"], ["XP Tests (dbg)(3)"], ["XP Tests (dbg)(4)"], ["XP Tests (dbg)(5)"], ["XP Tests (dbg)(6)"]]; - deepEqual(generateBuildersFromBuilderList(builderList, isChromiumDepsGTestRunner), expectedBuilders); -}); - -test('generateChromiumDepsCrosGTestBuildersFromBuilderList', 1, function() { - var builderList = ["ChromiumOS (amd64)", "ChromiumOS (arm)", "ChromiumOS (tegra2)", "ChromiumOS (x86)", "Linux ChromiumOS (Clang dbg)", "Linux ChromiumOS Builder", "Linux ChromiumOS Builder (dbg)", - "Linux ChromiumOS Tests (1)", "Linux ChromiumOS Tests (2)", "Linux ChromiumOS Tests (dbg)(1)", "Linux ChromiumOS Tests (dbg)(2)", "Linux ChromiumOS Tests (dbg)(3)"]; - var expectedBuilders = [["Linux ChromiumOS Tests (1)", 2], ["Linux ChromiumOS Tests (2)"], ["Linux ChromiumOS Tests (dbg)(1)"], ["Linux ChromiumOS Tests (dbg)(2)"], ["Linux ChromiumOS Tests (dbg)(3)"]]; - deepEqual(generateBuildersFromBuilderList(builderList, isChromiumDepsCrosGTestRunner), expectedBuilders); -}); - -test('generateChromiumTipOfTreeGTestBuildersFromBuilderList', 1, function() { - var builderList = ["Chrome Frame Tests", "GPU Linux (NVIDIA)", "GPU Linux (dbg) (NVIDIA)", "GPU Mac", "GPU Mac (dbg)", "GPU Win7 (NVIDIA)", "GPU Win7 (dbg) (NVIDIA)", "Linux Perf", - "Linux Tests", "Linux Valgrind", "Mac Builder (dbg)", "Mac10.6 Perf", "Mac10.6 Tests", "Vista Perf", "Vista Tests", "WebKit Linux", "WebKit Linux (dbg)", "WebKit Linux (deps)", - "WebKit Linux 32", "WebKit Mac Builder", "WebKit Mac Builder (dbg)", "WebKit Mac Builder (deps)", - "WebKit Mac10.6", "WebKit Mac10.6 (dbg)", "WebKit Mac10.6 (deps)", "WebKit Mac10.7", "WebKit Win", "WebKit Win (dbg)(1)", "WebKit Win (dbg)(2)", - "WebKit Win (deps)", "WebKit Win Builder", "WebKit Win Builder (dbg)", "WebKit Win Builder (deps)", "WebKit Win7", "Win (dbg)", "Win Builder"]; - var expectedBuilders = [['Linux Tests', BuilderGroup.DEFAULT_BUILDER], ['Mac10.6 Tests'], ['Vista Tests'], ['Win (dbg)']]; - deepEqual(generateBuildersFromBuilderList(builderList, isChromiumTipOfTreeGTestRunner), expectedBuilders); + "WebKit Mac10.6", "WebKit Mac10.6 (dbg)", "WebKit Mac10.6 (deps)", "WebKit Mac10.7", "WebKit Win", "WebKit Win (dbg)(1)", "WebKit Win (dbg)(2)", "WebKit Win (deps)", + "WebKit Win7", "Win (dbg)", "Win Builder"]; + var expectedBuilders = ["WebKit Linux (deps)", "WebKit Mac10.6 (deps)", "WebKit Win (deps)"]; + deepEqual(builderList.filter(isChromiumWebkitDepsTestRunner), expectedBuilders); }); test('queryHashAsMap', 2, function() { @@ -643,57 +589,26 @@ test('addBuilderLoadErrors', 1, function() { }); test('builderGroupIsToTWebKitAttribute', 2, function() { - var dummyMaster = new BuilderMaster('dummy.org', 'http://build.dummy.org'); + var dummyMaster = new builders.BuilderMaster('Chromium', 'dummyurl', {'layout-tests': {'builders': ['WebKit Linux', 'WebKit Linux (dbg)', 'WebKit Mac10.7', 'WebKit Win']}}); var testBuilderGroups = { '@ToT - dummy.org': new BuilderGroup(BuilderGroup.TOT_WEBKIT), '@DEPS - dummy.org': new BuilderGroup(BuilderGroup.DEPS_WEBKIT), } - testBuilderGroups['@ToT - dummy.org'].expectedGroups = 1; - testBuilderGroups['@DEPS - dummy.org'].expectedGroups = 1; var testJSONData = "{ \"Dummy Builder 1\": null, \"Dummy Builder 2\": null }"; - onBuilderListLoad(testBuilderGroups, function() { return true; }, dummyMaster, '@ToT - dummy.org', {responseText: testJSONData}); + requestBuilderList(testBuilderGroups, 'ChromiumWebkit', '@ToT - dummy.org', testBuilderGroups['@ToT - dummy.org'], 'layout-tests'); equal(testBuilderGroups['@ToT - dummy.org'].isToTWebKit, true); - onBuilderListLoad(testBuilderGroups, function() { return true; }, dummyMaster, '@DEPS - dummy.org', {responseText: testJSONData}); + requestBuilderList(testBuilderGroups, 'ChromiumWebkit', '@DEPS - dummy.org', testBuilderGroups['@DEPS - dummy.org'], 'layout-tests'); equal(testBuilderGroups['@DEPS - dummy.org'].isToTWebKit, false); }); -test('builderGroupExpectedGroups', 4, function() { - var dummyMaster = new BuilderMaster('dummy.org', 'http://build.dummy.org'); - var testBuilderGroups = { - '@ToT - dummy.org': new BuilderGroup(BuilderGroup.TOT_WEBKIT), - } - testBuilderGroups['@ToT - dummy.org'].expectedGroups = 3; - - var testJSONData = "{ \"Dummy Builder 1\": null }"; - equal(testBuilderGroups['@ToT - dummy.org'].expectedGroups, 3); - onBuilderListLoad(testBuilderGroups, function() { return true; }, dummyMaster, '@ToT - dummy.org', {responseText: testJSONData}); - equal(testBuilderGroups['@ToT - dummy.org'].groups, 1); - var testJSONData = "{ \"Dummy Builder 2\": null }"; - onBuilderListLoad(testBuilderGroups, function() { return true; }, dummyMaster, '@ToT - dummy.org', {responseText: testJSONData}); - equal(testBuilderGroups['@ToT - dummy.org'].groups, 2); - onErrorLoadingBuilderList('http://build.dummy.org', testBuilderGroups, '@ToT - dummy.org'); - equal(testBuilderGroups['@ToT - dummy.org'].groups, 3); -}); - -test('requestBuilderListAddsBuilderGroupEntry', 2, function() { +test('requestBuilderListAddsBuilderGroupEntry', 1, function() { var testBuilderGroups = { '@ToT - dummy.org': null }; + var builderGroup = new BuilderGroup(BuilderGroup.TOT_WEBKIT); + var groupName = '@ToT - dummy.org'; + requestBuilderList(testBuilderGroups, 'ChromiumWebkit', groupName, builderGroup, 'layout-tests'); - var requestFunction = loader.request; - loader.request = function() {}; - - try { - var builderFilter = null; - var master = { builderJsonPath: function() {} }; - var groupName = '@ToT - dummy.org'; - var builderGroup = { expectedGroups: 0 }; - requestBuilderList(testBuilderGroups, builderFilter, master, groupName, builderGroup); - - equal(testBuilderGroups['@ToT - dummy.org'], builderGroup); - equal(testBuilderGroups['@ToT - dummy.org'].expectedGroups, 1); - } finally { - loader.request = requestFunction; - } + equal(testBuilderGroups['@ToT - dummy.org'], builderGroup); }) test('sortTests', 4, function() { diff --git a/Tools/TestResultServer/static-dashboards/loader.js b/Tools/TestResultServer/static-dashboards/loader.js index be9e708a1..c74890161 100644 --- a/Tools/TestResultServer/static-dashboards/loader.js +++ b/Tools/TestResultServer/static-dashboards/loader.js @@ -71,11 +71,6 @@ loader.Loader.prototype = { { this._loadNext(); }, - buildersListLoaded: function() - { - initBuilders(); - this._loadNext(); - }, _loadNext: function() { var loadingStep = this._loadingSteps.shift(); @@ -88,6 +83,8 @@ loader.Loader.prototype = { _loadBuildersList: function() { loadBuildersList(g_crossDashboardState.group, g_crossDashboardState.testType); + initBuilders(); + this._loadNext(); }, _loadResultsFiles: function() { @@ -163,16 +160,10 @@ loader.Loader.prototype = { }, _handleResultsFileLoadError: function(builderName) { - var error = 'Failed to load results file for ' + builderName + '.'; - - if (isLayoutTestResults()) { - console.error(error); - g_buildersThatFailedToLoad.push(builderName); - } else { - // Avoid to show error/warning messages for non-layout tests. We may be - // checking the builders that are not running the tests. - console.info('info:' + error); - } + console.error('Failed to load results file for ' + builderName + '.'); + + // FIXME: loader shouldn't depend on state defined in dashboard_base.js. + g_buildersThatFailedToLoad.push(builderName); // Remove this builder from builders, so we don't try to use the // data that isn't there. diff --git a/Tools/TestResultServer/static-dashboards/loader_unittests.js b/Tools/TestResultServer/static-dashboards/loader_unittests.js index e2f546c09..881e0179a 100644 --- a/Tools/TestResultServer/static-dashboards/loader_unittests.js +++ b/Tools/TestResultServer/static-dashboards/loader_unittests.js @@ -74,11 +74,14 @@ test('results files loading', 5, function() { g_builders = {"WebKit Linux": true, "WebKit Win": true}; + builders.masters['ChromiumWebkit'] = {'tests': {'layout-tests': {builders: ["WebKit Linux", "WebKit Win"]}}}; + loadBuildersList('@ToT - chromium.org', 'layout-tests'); + try { resourceLoader._loadResultsFiles(); } finally { g_builders = undefined; - g_resultsByBuilder = undefined; + g_resultsByBuilder = {}; loader.request = requestFunction; } }); @@ -104,3 +107,27 @@ test('expectations files loading', 1, function() { loader.request = requestFunction; } }); + +test('results file failing to load', 2, function() { + // FIXME: loader shouldn't depend on state defined in dashboard_base.js. + g_buildersThatFailedToLoad = []; + g_builders = {}; + + var resourceLoader = new loader.Loader(); + var resourceLoadCount = 0; + resourceLoader._handleResourceLoad = function() { + resourceLoadCount++; + } + + var builder1 = 'builder1'; + g_builders[builder1] = true; + resourceLoader._handleResultsFileLoadError(builder1); + + var builder2 = 'builder2'; + g_builders[builder2] = true; + resourceLoader._handleResultsFileLoadError(builder2); + + deepEqual(g_buildersThatFailedToLoad, [builder1, builder2]); + equal(resourceLoadCount, 2); + +}) diff --git a/Tools/TestResultServer/static-dashboards/run-embedded-unittests.html b/Tools/TestResultServer/static-dashboards/run-embedded-unittests.html index 835be21da..a863873c3 100644 --- a/Tools/TestResultServer/static-dashboards/run-embedded-unittests.html +++ b/Tools/TestResultServer/static-dashboards/run-embedded-unittests.html @@ -40,28 +40,25 @@ THE POSSIBILITY OF SUCH DAMAGE. <link rel="stylesheet" href="flakiness_dashboard.css"></link> <link rel="stylesheet" href="flakiness_dashboard_tests.css"></link> <script src="builders.js"></script> +<script src="builders_unittests.js"></script> <script> -// Don't request the actual builders off the bots when running unittests. -function loadBuildersList() {}; -function g_handleBuildersListLoaded() {}; - // Mimic being embedded. All our embedded checks compare window and parent. window.parent = null; </script> <script src="dashboard_base.js"></script> +<script src="loader.js"></script> +<script src="loader_unittests.js"></script> <script src="flakiness_dashboard.js"></script> <script> window.location.href = '#useTestData=true'; -var builderGroup = '@ToT - chromium.org'; -var builders = {'Webkit Linux': '', 'Webkit Linux (dbg)': '', 'Webkit Mac10.7': '', 'Webkit Win': ''}; -onBuilderListLoad(LAYOUT_TESTS_BUILDER_GROUPS, isChromiumWebkitTipOfTreeTestRunner, CHROMIUM_WEBKIT_BUILDER_MASTER, builderGroup, BuilderGroup.TOT_WEBKIT, builders); -initBuilders(); </script> -<!-- FIXME: Split this up into multiple unittest.js, e.g. one for builders.js and one for dashboard_base.js. --> <script src="flakiness_dashboard_embedded_unittests.js"></script> +<!-- FIXME: Split this up into multiple unittest.js, e.g. one for builders.js and one for dashboard_base.js. --> +<script src="flakiness_dashboard_unittests.js"></script> + </body> </html> diff --git a/Tools/TestResultServer/static-dashboards/run-unittests.html b/Tools/TestResultServer/static-dashboards/run-unittests.html index 9999c71f9..452d55452 100644 --- a/Tools/TestResultServer/static-dashboards/run-unittests.html +++ b/Tools/TestResultServer/static-dashboards/run-unittests.html @@ -40,28 +40,17 @@ THE POSSIBILITY OF SUCH DAMAGE. <link rel="stylesheet" href="flakiness_dashboard.css"></link> <link rel="stylesheet" href="flakiness_dashboard_tests.css"></link> <script src="builders.js"></script> - -<script> -// Don't request the actual builders off the bots when running unittests. -function loadBuildersList() {}; -</script> - +<script src="builders_unittests.js"></script> <script src="dashboard_base.js"></script> <script src="loader.js"></script> +<script src="loader_unittests.js"></script> <script src="flakiness_dashboard.js"></script> <script> window.location.href = '#useTestData=true'; -var groupName = '@ToT - chromium.org'; -var builders = '{"WebKit Linux": true, "WebKit Linux (dbg)": true, "WebKit Mac10.7": true, "WebKit Win": true}'; -LAYOUT_TESTS_BUILDER_GROUPS[groupName] = new BuilderGroup(BuilderGroup.TOT_WEBKIT); -LAYOUT_TESTS_BUILDER_GROUPS[groupName].expectedGroups = 4; -onBuilderListLoad(LAYOUT_TESTS_BUILDER_GROUPS, isChromiumWebkitTipOfTreeTestRunner, CHROMIUM_WEBKIT_BUILDER_MASTER, groupName, {responseText: builders}); -initBuilders(); </script> <!-- FIXME: Split this up into multiple unittest.js, e.g. one for builders.js and one for dashboard_base.js. --> <script src="flakiness_dashboard_unittests.js"></script> -<script src="loader_unittests.js"></script> </body> </html> diff --git a/Tools/TestResultServer/static-dashboards/timeline_explorer.html b/Tools/TestResultServer/static-dashboards/timeline_explorer.html index b3fa41bc3..4cdd9a86b 100644 --- a/Tools/TestResultServer/static-dashboards/timeline_explorer.html +++ b/Tools/TestResultServer/static-dashboards/timeline_explorer.html @@ -286,7 +286,7 @@ function updateBuildInspector(results, builder, dygraph, index) addRow('', ''); var master = builderMaster(builder); var buildUrl = master.logPath(builder, results[BUILD_NUMBERS_KEY][index]); - if (master == WEBKIT_BUILDER_MASTER) { + if (master.name == WEBKIT_BUILDER_MASTER) { var resultsUrl = 'http://build.webkit.org/results/' + builder + '/r' + results[WEBKIT_REVISIONS_KEY][index] + ' (' + results[BUILD_NUMBERS_KEY][index] + ')'; } else { diff --git a/Tools/TestWebKitAPI/CMakeLists.txt b/Tools/TestWebKitAPI/CMakeLists.txt index 163edc753..16033ec15 100644 --- a/Tools/TestWebKitAPI/CMakeLists.txt +++ b/Tools/TestWebKitAPI/CMakeLists.txt @@ -3,6 +3,7 @@ SET(TESTWEBKITAPI_DIR "${TOOLS_DIR}/TestWebKitAPI") INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR} ${TESTWEBKITAPI_DIR} ${CMAKE_SOURCE_DIR}/Source + ${DERIVED_SOURCES_WEBCORE_DIR} ${DERIVED_SOURCES_WEBKIT2_DIR}/include ${JAVASCRIPTCORE_DIR} ${JAVASCRIPTCORE_DIR}/API @@ -93,9 +94,9 @@ ADD_TEST(test_wtf ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_wtf) SET_TESTS_PROPERTIES(test_wtf PROPERTIES TIMEOUT 60) SET(test_webcore_LIBRARIES + gtest ${WTF_LIBRARY_NAME} ${WebCore_LIBRARY_NAME} - gtest ) ADD_EXECUTABLE(test_webcore diff --git a/Tools/TestWebKitAPI/PlatformEfl.cmake b/Tools/TestWebKitAPI/PlatformEfl.cmake index 7defb1138..d6d913005 100644 --- a/Tools/TestWebKitAPI/PlatformEfl.cmake +++ b/Tools/TestWebKitAPI/PlatformEfl.cmake @@ -1,9 +1,11 @@ ADD_CUSTOM_TARGET(forwarding-headersEflForTestWebKitAPI + COMMAND ${PERL_EXECUTABLE} ${WEBKIT2_DIR}/Scripts/generate-forwarding-headers.pl ${WEBKIT2_DIR} ${DERIVED_SOURCES_WEBKIT2_DIR}/include efl COMMAND ${PERL_EXECUTABLE} ${WEBKIT2_DIR}/Scripts/generate-forwarding-headers.pl ${TESTWEBKITAPI_DIR} ${DERIVED_SOURCES_WEBKIT2_DIR}/include efl ) SET(ForwardingHeadersForTestWebKitAPI_NAME forwarding-headersEflForTestWebKitAPI) ADD_CUSTOM_TARGET(forwarding-headersSoupForTestWebKitAPI + COMMAND ${PERL_EXECUTABLE} ${WEBKIT2_DIR}/Scripts/generate-forwarding-headers.pl ${WEBKIT2_DIR} ${DERIVED_SOURCES_WEBKIT2_DIR}/include soup COMMAND ${PERL_EXECUTABLE} ${WEBKIT2_DIR}/Scripts/generate-forwarding-headers.pl ${TESTWEBKITAPI_DIR} ${DERIVED_SOURCES_WEBKIT2_DIR}/include soup ) SET(ForwardingNetworkHeadersForTestWebKitAPI_NAME forwarding-headersSoupForTestWebKitAPI) diff --git a/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj b/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj index dc256b47d..249fc4aa6 100644 --- a/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj +++ b/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj @@ -32,6 +32,8 @@ 26F1B44415CA434F00D1E4BF /* AtomicString.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26F1B44215CA434F00D1E4BF /* AtomicString.cpp */; }; 26F1B44515CA434F00D1E4BF /* StringImpl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26F1B44315CA434F00D1E4BF /* StringImpl.cpp */; }; 2943BE86161DFEB800999E3D /* UserContentTest.mm in Sources */ = {isa = PBXBuildFile; fileRef = 2943BE84161DFEB800999E3D /* UserContentTest.mm */; }; + 29AB8AA1164C735800D49BEC /* CustomProtocolsTest.mm in Sources */ = {isa = PBXBuildFile; fileRef = 29AB8A9F164C735800D49BEC /* CustomProtocolsTest.mm */; }; + 29AB8AA4164C7A9300D49BEC /* TestBrowsingContextLoadDelegate.mm in Sources */ = {isa = PBXBuildFile; fileRef = 29AB8AA2164C7A9300D49BEC /* TestBrowsingContextLoadDelegate.mm */; }; 333B9CE21277F23100FEFCE3 /* PreventEmptyUserAgent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 333B9CE11277F23100FEFCE3 /* PreventEmptyUserAgent.cpp */; }; 33BE5AF5137B5A6C00705813 /* MouseMoveAfterCrash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 33BE5AF4137B5A6C00705813 /* MouseMoveAfterCrash.cpp */; }; 33BE5AF9137B5AAE00705813 /* MouseMoveAfterCrash_Bundle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 33BE5AF8137B5AAE00705813 /* MouseMoveAfterCrash_Bundle.cpp */; }; @@ -274,6 +276,9 @@ 26F1B44215CA434F00D1E4BF /* AtomicString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AtomicString.cpp; path = WTF/AtomicString.cpp; sourceTree = "<group>"; }; 26F1B44315CA434F00D1E4BF /* StringImpl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StringImpl.cpp; path = WTF/StringImpl.cpp; sourceTree = "<group>"; }; 2943BE84161DFEB800999E3D /* UserContentTest.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = UserContentTest.mm; path = WebKit2ObjC/UserContentTest.mm; sourceTree = "<group>"; }; + 29AB8A9F164C735800D49BEC /* CustomProtocolsTest.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = CustomProtocolsTest.mm; path = WebKit2ObjC/CustomProtocolsTest.mm; sourceTree = "<group>"; }; + 29AB8AA2164C7A9300D49BEC /* TestBrowsingContextLoadDelegate.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = TestBrowsingContextLoadDelegate.mm; sourceTree = "<group>"; }; + 29AB8AA3164C7A9300D49BEC /* TestBrowsingContextLoadDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TestBrowsingContextLoadDelegate.h; sourceTree = "<group>"; }; 333B9CE11277F23100FEFCE3 /* PreventEmptyUserAgent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PreventEmptyUserAgent.cpp; sourceTree = "<group>"; }; 33BE5AF4137B5A6C00705813 /* MouseMoveAfterCrash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MouseMoveAfterCrash.cpp; sourceTree = "<group>"; }; 33BE5AF8137B5AAE00705813 /* MouseMoveAfterCrash_Bundle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MouseMoveAfterCrash_Bundle.cpp; sourceTree = "<group>"; }; @@ -541,6 +546,7 @@ BC3C4C6F14575B1D0025FB62 /* WebKit2 Objective-C */ = { isa = PBXGroup; children = ( + 29AB8A9F164C735800D49BEC /* CustomProtocolsTest.mm */, 2943BE84161DFEB800999E3D /* UserContentTest.mm */, BC3C4C7D14587AA60025FB62 /* WKBrowsingContextGroupTest.mm */, BC3C4C7014575B6A0025FB62 /* WKBrowsingContextLoadDelegateTest.mm */, @@ -711,6 +717,8 @@ BC90955C125548AA00083756 /* PlatformWebViewMac.mm */, C081224313FC19EC00DC39AE /* SyntheticBackingScaleFactorWindow.h */, C081224413FC19EC00DC39AE /* SyntheticBackingScaleFactorWindow.m */, + 29AB8AA3164C7A9300D49BEC /* TestBrowsingContextLoadDelegate.h */, + 29AB8AA2164C7A9300D49BEC /* TestBrowsingContextLoadDelegate.mm */, C08587BE13FE956C001EF4E5 /* WebKitAgnosticTest.h */, C08587BD13FE956C001EF4E5 /* WebKitAgnosticTest.mm */, ); @@ -1016,6 +1024,8 @@ 4F4D2C0E1626FE2700320FE1 /* MemoryInstrumentationTest.cpp in Sources */, 378E64731632646D00B6C676 /* InjectedBundleFrameHitTest.cpp in Sources */, FE217ECD1640A54A0052988B /* VMInspector.cpp in Sources */, + 29AB8AA1164C735800D49BEC /* CustomProtocolsTest.mm in Sources */, + 29AB8AA4164C7A9300D49BEC /* TestBrowsingContextLoadDelegate.mm in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; diff --git a/Tools/TestWebKitAPI/Tests/WTF/MemoryInstrumentationTest.cpp b/Tools/TestWebKitAPI/Tests/WTF/MemoryInstrumentationTest.cpp index 1ac26a0be..7348062d9 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/MemoryInstrumentationTest.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/MemoryInstrumentationTest.cpp @@ -90,7 +90,7 @@ public: result.iterator->value += size; } virtual bool visited(const void* object) { return !m_visitedObjects.add(object).isNewEntry; } - virtual void checkCountedObject(const void*) { } + virtual bool checkCountedObject(const void*) { return true; } size_t visitedObjects() const { return m_visitedObjects.size(); } size_t totalSize(const MemoryObjectType objectType) const @@ -816,10 +816,11 @@ TEST(MemoryInstrumentationTest, instrumentedWithMultipleAncestors) class CheckCountedObjectsClient : public MemoryInstrumentationTestClient { public: CheckCountedObjectsClient(const void* expectedPointer) : m_expectedPointer(expectedPointer), m_expectedPointerFound(false) { } - virtual void checkCountedObject(const void* pointer) + virtual bool checkCountedObject(const void* pointer) { EXPECT_EQ(pointer, m_expectedPointer); m_expectedPointerFound = true; + return true; } bool expectedPointerFound() { return m_expectedPointerFound; } diff --git a/Tools/TestWebKitAPI/Tests/WebKit2ObjC/CustomProtocolsTest.mm b/Tools/TestWebKitAPI/Tests/WebKit2ObjC/CustomProtocolsTest.mm new file mode 100644 index 000000000..0454f3f38 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WebKit2ObjC/CustomProtocolsTest.mm @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2012 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#import "config.h" +#import "Test.h" + +#import "PlatformUtilities.h" +#import "TestBrowsingContextLoadDelegate.h" +#import <Foundation/Foundation.h> +#import <WebKit2/WebKit2.h> + +static NSString *testScheme = @"test"; +static NSString *testHost = @"test"; +static bool testFinished = false; + +@interface TestProtocol : NSURLProtocol { +} +@end + +@implementation TestProtocol + ++ (BOOL)canInitWithRequest:(NSURLRequest *)request +{ + return [[[request URL] scheme] caseInsensitiveCompare:testScheme] == NSOrderedSame; +} + ++ (NSURLRequest *)canonicalRequestForRequest:(NSURLRequest *)request +{ + return request; +} + ++ (BOOL)requestIsCacheEquivalent:(NSURLRequest *)a toRequest:(NSURLRequest *)b +{ + return NO; +} + +- (void)startLoading +{ + EXPECT_TRUE([[[[self request] URL] scheme] isEqualToString:testScheme]); + EXPECT_TRUE([[[[self request] URL] host] isEqualToString:testHost]); + + NSData *data = [@"<body>PASS</body>" dataUsingEncoding:NSASCIIStringEncoding]; + NSURLResponse *response = [[NSURLResponse alloc] initWithURL:[[self request] URL] MIMEType:@"text/html" expectedContentLength:[data length] textEncodingName:nil]; + [[self client] URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed]; + [[self client] URLProtocol:self didLoadData:data]; + [[self client] URLProtocolDidFinishLoading:self]; + [response release]; +} + +- (void)stopLoading +{ +} + +@end + +TEST(WebKit2CustomProtocolsTest, CustomProtocolUsed) +{ + [NSURLProtocol registerClass:[TestProtocol class]]; + [WKBrowsingContextController registerSchemeForCustomProtocol:testScheme]; + + WKProcessGroup *processGroup = [[WKProcessGroup alloc] init]; + WKBrowsingContextGroup *browsingContextGroup = [[WKBrowsingContextGroup alloc] initWithIdentifier:@"TestIdentifier"]; + WKView *wkView = [[WKView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) processGroup:processGroup browsingContextGroup:browsingContextGroup]; + wkView.browsingContextController.loadDelegate = [[TestBrowsingContextLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { + testFinished = true; + }]; + [wkView.browsingContextController loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:[NSString stringWithFormat:@"%@://%@", testScheme, testHost]]]]; + + TestWebKitAPI::Util::run(&testFinished); +}
\ No newline at end of file diff --git a/Tools/TestWebKitAPI/Tests/WebKit2ObjC/UserContentTest.mm b/Tools/TestWebKitAPI/Tests/WebKit2ObjC/UserContentTest.mm index d87ad5ed5..025896373 100644 --- a/Tools/TestWebKitAPI/Tests/WebKit2ObjC/UserContentTest.mm +++ b/Tools/TestWebKitAPI/Tests/WebKit2ObjC/UserContentTest.mm @@ -27,6 +27,7 @@ #import "Test.h" #import "PlatformUtilities.h" +#import "TestBrowsingContextLoadDelegate.h" #import <JavaScriptCore/JSRetainPtr.h> #import <JavaScriptCore/JavaScriptCore.h> #import <WebKit2/WKSerializedScriptValue.h> @@ -42,40 +43,6 @@ static const char* greenInRGB = "rgb(0, 128, 0)"; static const char* redInRGB = "rgb(255, 0, 0)"; static const char* userScriptTestProperty = "window._userScriptInstalled"; -typedef void (^OnLoadBlock)(WKBrowsingContextController *); - -@interface UserContentTestLoadDelegate : NSObject <WKBrowsingContextLoadDelegate> -{ - OnLoadBlock _onLoadBlock; -} - -@property (nonatomic, copy) OnLoadBlock onLoadBlock; - -- (id)initWithBlockToRunOnLoad:(OnLoadBlock)block; - -@end - -@implementation UserContentTestLoadDelegate - -@synthesize onLoadBlock = _onLoadBlock; - -- (id)initWithBlockToRunOnLoad:(OnLoadBlock)block -{ - if (!(self = [super init])) - return nil; - - self.onLoadBlock = block; - return self; -} - -- (void)browsingContextControllerDidFinishLoad:(WKBrowsingContextController *)sender -{ - if (_onLoadBlock) - _onLoadBlock(sender); -} - -@end - namespace { class WebKit2UserContentTest : public ::testing::Test { public: @@ -143,7 +110,7 @@ TEST_F(WebKit2UserContentTest, AddUserStyleSheetBeforeCreatingView) WKView *wkView = [[WKView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) processGroup:processGroup browsingContextGroup:browsingContextGroup]; WKStringRef backgroundColorQuery = WKStringCreateWithUTF8CString(backgroundColorScript); - wkView.browsingContextController.loadDelegate = [[UserContentTestLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { + wkView.browsingContextController.loadDelegate = [[TestBrowsingContextLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { WKPageRunJavaScriptInMainFrame_b(wkView.pageRef, backgroundColorQuery, ^(WKSerializedScriptValueRef serializedScriptValue, WKErrorRef error) { expectScriptValueIsString(serializedScriptValue, greenInRGB); testFinished = true; @@ -162,7 +129,7 @@ TEST_F(WebKit2UserContentTest, AddUserStyleSheetAfterCreatingView) WKView *wkView = [[WKView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) processGroup:processGroup browsingContextGroup:browsingContextGroup]; WKStringRef backgroundColorQuery = WKStringCreateWithUTF8CString(backgroundColorScript); - wkView.browsingContextController.loadDelegate = [[UserContentTestLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { + wkView.browsingContextController.loadDelegate = [[TestBrowsingContextLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { WKPageRunJavaScriptInMainFrame_b(wkView.pageRef, backgroundColorQuery, ^(WKSerializedScriptValueRef serializedScriptValue, WKErrorRef error) { expectScriptValueIsString(serializedScriptValue, greenInRGB); testFinished = true; @@ -184,7 +151,7 @@ TEST_F(WebKit2UserContentTest, RemoveAllUserStyleSheets) WKView *wkView = [[WKView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) processGroup:processGroup browsingContextGroup:browsingContextGroup]; WKStringRef backgroundColorQuery = WKStringCreateWithUTF8CString(backgroundColorScript); - wkView.browsingContextController.loadDelegate = [[UserContentTestLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { + wkView.browsingContextController.loadDelegate = [[TestBrowsingContextLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { WKPageRunJavaScriptInMainFrame_b(wkView.pageRef, backgroundColorQuery, ^(WKSerializedScriptValueRef serializedScriptValue, WKErrorRef error) { expectScriptValueIsString(serializedScriptValue, redInRGB); testFinished = true; @@ -206,7 +173,7 @@ TEST_F(WebKit2UserContentTest, AddUserScriptBeforeCreatingView) WKView *wkView = [[WKView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) processGroup:processGroup browsingContextGroup:browsingContextGroup]; WKStringRef userScriptTestPropertyString = WKStringCreateWithUTF8CString(userScriptTestProperty); - wkView.browsingContextController.loadDelegate = [[UserContentTestLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { + wkView.browsingContextController.loadDelegate = [[TestBrowsingContextLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { WKPageRunJavaScriptInMainFrame_b(wkView.pageRef, userScriptTestPropertyString, ^(WKSerializedScriptValueRef serializedScriptValue, WKErrorRef error) { expectScriptValueIsBoolean(serializedScriptValue, true); testFinished = true; @@ -225,7 +192,7 @@ TEST_F(WebKit2UserContentTest, AddUserScriptAfterCreatingView) WKView *wkView = [[WKView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) processGroup:processGroup browsingContextGroup:browsingContextGroup]; WKStringRef userScriptTestPropertyString = WKStringCreateWithUTF8CString(userScriptTestProperty); - wkView.browsingContextController.loadDelegate = [[UserContentTestLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { + wkView.browsingContextController.loadDelegate = [[TestBrowsingContextLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { WKPageRunJavaScriptInMainFrame_b(wkView.pageRef, userScriptTestPropertyString, ^(WKSerializedScriptValueRef serializedScriptValue, WKErrorRef error) { expectScriptValueIsBoolean(serializedScriptValue, true); testFinished = true; @@ -247,7 +214,7 @@ TEST_F(WebKit2UserContentTest, RemoveAllUserScripts) WKView *wkView = [[WKView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) processGroup:processGroup browsingContextGroup:browsingContextGroup]; WKStringRef userScriptTestPropertyString = WKStringCreateWithUTF8CString(userScriptTestProperty); - wkView.browsingContextController.loadDelegate = [[UserContentTestLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { + wkView.browsingContextController.loadDelegate = [[TestBrowsingContextLoadDelegate alloc] initWithBlockToRunOnLoad:^(WKBrowsingContextController *sender) { WKPageRunJavaScriptInMainFrame_b(wkView.pageRef, userScriptTestPropertyString, ^(WKSerializedScriptValueRef serializedScriptValue, WKErrorRef error) { expectScriptValueIsUndefined(serializedScriptValue); testFinished = true; diff --git a/Tools/TestWebKitAPI/efl/PlatformWebView.cpp b/Tools/TestWebKitAPI/efl/PlatformWebView.cpp index 8970957de..2e87f7087 100644 --- a/Tools/TestWebKitAPI/efl/PlatformWebView.cpp +++ b/Tools/TestWebKitAPI/efl/PlatformWebView.cpp @@ -60,6 +60,7 @@ PlatformWebView::PlatformWebView(WKContextRef contextRef, WKPageGroupRef pageGro Evas* evas = ecore_evas_get(m_window); m_view = toImpl(WKViewCreate(evas, contextRef, pageGroupRef)); ewk_view_theme_set(m_view, THEME_DIR"/default.edj"); + resizeTo(600, 800); } PlatformWebView::~PlatformWebView() @@ -69,6 +70,11 @@ PlatformWebView::~PlatformWebView() ecore_evas_shutdown(); } +void PlatformWebView::resizeTo(unsigned width, unsigned height) +{ + evas_object_resize(m_view, width, height); +} + WKPageRef PlatformWebView::page() const { return WKViewGetPage(toAPI(m_view)); diff --git a/Tools/TestWebKitAPI/mac/TestBrowsingContextLoadDelegate.h b/Tools/TestWebKitAPI/mac/TestBrowsingContextLoadDelegate.h new file mode 100644 index 000000000..d8f8ffa95 --- /dev/null +++ b/Tools/TestWebKitAPI/mac/TestBrowsingContextLoadDelegate.h @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2012 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#import <WebKit2/WebKit2.h> + +typedef void (^OnLoadBlock)(WKBrowsingContextController *); + +@interface TestBrowsingContextLoadDelegate : NSObject <WKBrowsingContextLoadDelegate> { +@private + OnLoadBlock _onLoadBlock; +} + +@property(nonatomic, copy) OnLoadBlock onLoadBlock; + +- (id)initWithBlockToRunOnLoad:(OnLoadBlock)block; + +@end diff --git a/Tools/TestWebKitAPI/mac/TestBrowsingContextLoadDelegate.mm b/Tools/TestWebKitAPI/mac/TestBrowsingContextLoadDelegate.mm new file mode 100644 index 000000000..a6c8cef94 --- /dev/null +++ b/Tools/TestWebKitAPI/mac/TestBrowsingContextLoadDelegate.mm @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2012 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "TestBrowsingContextLoadDelegate.h" + +@implementation TestBrowsingContextLoadDelegate + +@synthesize onLoadBlock = _onLoadBlock; + +- (id)initWithBlockToRunOnLoad:(OnLoadBlock)block +{ + if (!(self = [super init])) + return nil; + + self.onLoadBlock = block; + return self; +} + +- (void)browsingContextControllerDidFinishLoad:(WKBrowsingContextController *)sender +{ + if (_onLoadBlock) + _onLoadBlock(sender); +} + +@end
\ No newline at end of file diff --git a/Tools/WebKitTestRunner/CMakeLists.txt b/Tools/WebKitTestRunner/CMakeLists.txt index 37c500a5c..84404e848 100644 --- a/Tools/WebKitTestRunner/CMakeLists.txt +++ b/Tools/WebKitTestRunner/CMakeLists.txt @@ -40,6 +40,7 @@ SET(WebKitTestRunner_INCLUDE_DIRECTORIES ${WEBKIT2_DIR}/UIProcess/API/C/efl ${WEBKIT2_DIR}/UIProcess/API/C/soup ${WTF_DIR} + ${DERIVED_SOURCES_WEBCORE_DIR} ${DERIVED_SOURCES_WEBCORE_DIR}/include ${DERIVED_SOURCES_WEBKIT2_DIR}/include ${DERIVED_SOURCES_DIR}/InjectedBundle @@ -64,7 +65,16 @@ SET(WebKitTestRunnerInjectedBundle_SOURCES ${WEBKIT_TESTRUNNER_INJECTEDBUNDLE_DIR}/Bindings/JSWrapper.cpp ) -FILE(GLOB WebKitTestRunnerInjectedBundle_IDL_FILES "${WEBKIT_TESTRUNNER_INJECTEDBUNDLE_DIR}/Bindings/*.idl") +SET(WebKitTestRunnerInjectedBundle_IDL_FILES + "${WEBKIT_TESTRUNNER_INJECTEDBUNDLE_DIR}/Bindings/AccessibilityController.idl" + "${WEBKIT_TESTRUNNER_INJECTEDBUNDLE_DIR}/Bindings/AccessibilityTextMarker.idl" + "${WEBKIT_TESTRUNNER_INJECTEDBUNDLE_DIR}/Bindings/AccessibilityTextMarkerRange.idl" + "${WEBKIT_TESTRUNNER_INJECTEDBUNDLE_DIR}/Bindings/AccessibilityUIElement.idl" + "${WEBKIT_TESTRUNNER_INJECTEDBUNDLE_DIR}/Bindings/EventSendingController.idl" + "${WEBKIT_TESTRUNNER_INJECTEDBUNDLE_DIR}/Bindings/GCController.idl" + "${WEBKIT_TESTRUNNER_INJECTEDBUNDLE_DIR}/Bindings/TestRunner.idl" + "${WEBKIT_TESTRUNNER_INJECTEDBUNDLE_DIR}/Bindings/TextInputController.idl" +) GENERATE_BINDINGS(WebKitTestRunnerInjectedBundle_SOURCES "${WebKitTestRunnerInjectedBundle_IDL_FILES}" diff --git a/Tools/WebKitTestRunner/DerivedSources.make b/Tools/WebKitTestRunner/DerivedSources.make index 501df5911..d3f3308c7 100644 --- a/Tools/WebKitTestRunner/DerivedSources.make +++ b/Tools/WebKitTestRunner/DerivedSources.make @@ -40,7 +40,6 @@ SCRIPTS = \ $(WebCoreScripts)/CodeGenerator.pm \ $(WebKitTestRunner)/InjectedBundle/Bindings/CodeGeneratorTestRunner.pm \ $(WebCoreScripts)/IDLParser.pm \ - $(WebCoreScripts)/IDLStructure.pm \ $(WebCoreScripts)/generate-bindings.pl \ # diff --git a/Tools/WebKitTestRunner/GNUmakefile.am b/Tools/WebKitTestRunner/GNUmakefile.am index a8a2fad56..37060034d 100644 --- a/Tools/WebKitTestRunner/GNUmakefile.am +++ b/Tools/WebKitTestRunner/GNUmakefile.am @@ -94,6 +94,8 @@ Libraries_libTestRunnerInjectedBundle_la_SOURCES = \ Tools/WebKitTestRunner/InjectedBundle/AccessibilityUIElement.cpp \ Tools/WebKitTestRunner/InjectedBundle/AccessibilityUIElement.h \ Tools/WebKitTestRunner/InjectedBundle/ActivateFonts.h \ + Tools/WebKitTestRunner/InjectedBundle/atk/AccessibilityControllerAtk.cpp \ + Tools/WebKitTestRunner/InjectedBundle/atk/AccessibilityUIElementAtk.cpp \ Tools/WebKitTestRunner/InjectedBundle/Bindings/JSWrappable.h \ Tools/WebKitTestRunner/InjectedBundle/Bindings/JSWrapper.cpp \ Tools/WebKitTestRunner/InjectedBundle/Bindings/JSWrapper.h \ @@ -101,8 +103,6 @@ Libraries_libTestRunnerInjectedBundle_la_SOURCES = \ Tools/WebKitTestRunner/InjectedBundle/EventSendingController.h \ Tools/WebKitTestRunner/InjectedBundle/GCController.cpp \ Tools/WebKitTestRunner/InjectedBundle/GCController.h \ - Tools/WebKitTestRunner/InjectedBundle/gtk/AccessibilityControllerGtk.cpp \ - Tools/WebKitTestRunner/InjectedBundle/gtk/AccessibilityUIElementGtk.cpp \ Tools/WebKitTestRunner/InjectedBundle/gtk/ActivateFontsGtk.cpp \ Tools/WebKitTestRunner/InjectedBundle/gtk/InjectedBundleGtk.cpp \ Tools/WebKitTestRunner/InjectedBundle/gtk/TestRunnerGtk.cpp \ @@ -150,7 +150,6 @@ code_generation_dependencies = \ Tools/WebKitTestRunner/InjectedBundle/Bindings/CodeGeneratorTestRunner.pm \ Source/WebCore/bindings/scripts/CodeGenerator.pm \ Source/WebCore/bindings/scripts/IDLParser.pm \ - Source/WebCore/bindings/scripts/IDLStructure.pm \ Source/WebCore/bindings/scripts/InFilesParser.pm \ Source/WebCore/bindings/scripts/generate-bindings.pl @@ -168,7 +167,6 @@ EXTRA_DIST += \ $(srcdir)/Tools/WebKitTestRunner/InjectedBundle/Bindings/CodeGeneratorTestRunner.pm \ $(srcdir)/Source/WebCore/bindings/scripts/CodeGenerator.pm \ $(srcdir)/Source/WebCore/bindings/scripts/IDLParser.pm \ - $(srcdir)/Source/WebCore/bindings/scripts/IDLStructure.pm \ $(srcdir)/Source/WebCore/bindings/scripts/InFilesParser.pm \ $(srcdir)/Source/WebCore/bindings/scripts/generate-bindings.pl \ $(shell ls $(srcdir)/Tools/WebKitTestRunner/InjectedBundle/Bindings/*.idl) diff --git a/Tools/WebKitTestRunner/InjectedBundle/Bindings/CodeGeneratorTestRunner.pm b/Tools/WebKitTestRunner/InjectedBundle/Bindings/CodeGeneratorTestRunner.pm index 4429283e8..7383946b3 100644 --- a/Tools/WebKitTestRunner/InjectedBundle/Bindings/CodeGeneratorTestRunner.pm +++ b/Tools/WebKitTestRunner/InjectedBundle/Bindings/CodeGeneratorTestRunner.pm @@ -30,11 +30,10 @@ package CodeGeneratorTestRunner; sub new { - my ($class, $codeGenerator, $outputDir, $outputHeaderDir, $layerOnTop, $preprocessor, $writeDependencies, $verbose, $idlFilePath) = @_; + my ($class, $codeGenerator, $layerOnTop, $preprocessor, $writeDependencies, $verbose, $idlFilePath) = @_; my $reference = { codeGenerator => $codeGenerator, - outputDir => $outputDir, idlFilePath => $idlFilePath, }; @@ -42,25 +41,21 @@ sub new return $reference; } -sub GenerateModule +sub GenerateInterface { } -sub GenerateInterface +sub WriteData { - my ($self, $interface, $defines) = @_; + my ($self, $interface, $outputDir) = @_; foreach my $file ($self->_generateHeaderFile($interface), $self->_generateImplementationFile($interface)) { - open(FILE, ">", File::Spec->catfile($$self{outputDir}, $$file{name})) or die "Failed to open $$file{name} for writing: $!"; + open(FILE, ">", File::Spec->catfile($outputDir, $$file{name})) or die "Failed to open $$file{name} for writing: $!"; print FILE @{$$file{contents}}; close(FILE) or die "Failed to close $$file{name} after writing: $!"; } } -sub finish -{ -} - sub _className { my ($idlType) = @_; diff --git a/Tools/WebKitTestRunner/InjectedBundle/DerivedSources.pri b/Tools/WebKitTestRunner/InjectedBundle/DerivedSources.pri index 8a2fa4dce..c8e4f5b81 100644 --- a/Tools/WebKitTestRunner/InjectedBundle/DerivedSources.pri +++ b/Tools/WebKitTestRunner/InjectedBundle/DerivedSources.pri @@ -29,7 +29,6 @@ idl.commands = perl -I$${ROOT_WEBKIT_DIR}/Source/WebCore/bindings/scripts -I$$PW idl.depends = $${ROOT_WEBKIT_DIR}/Source/WebCore/bindings/scripts/CodeGenerator.pm \ $$PWD/Bindings/CodeGeneratorTestRunner.pm \ $${ROOT_WEBKIT_DIR}/Source/WebCore/bindings/scripts/IDLParser.pm \ - $${ROOT_WEBKIT_DIR}/Source/WebCore/bindings/scripts/IDLStructure.pm \ $${ROOT_WEBKIT_DIR}/Source/WebCore/bindings/scripts/InFilesParser.pm \ $${ROOT_WEBKIT_DIR}/Source/WebCore/bindings/scripts/generate-bindings.pl GENERATORS += idl diff --git a/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp b/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp index 9a5e8075c..0684d6df2 100644 --- a/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp +++ b/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp @@ -103,6 +103,9 @@ void InjectedBundle::initialize(WKBundleRef bundle, WKTypeRef initializationUser activateFonts(); WKBundleActivateMacFontAscentHack(m_bundle); + + // FIXME: We'd like to start with a clean state for every test, but this function can't be used more than once yet. + WKBundleSwitchNetworkLoaderToNewTestingSession(m_bundle); } void InjectedBundle::didCreatePage(WKBundlePageRef page) @@ -242,7 +245,6 @@ void InjectedBundle::beginTesting(WKDictionaryRef settings) WKBundleSetAllowUniversalAccessFromFileURLs(m_bundle, m_pageGroup, true); WKBundleSetJavaScriptCanAccessClipboard(m_bundle, m_pageGroup, true); WKBundleSetPrivateBrowsingEnabled(m_bundle, m_pageGroup, false); - WKBundleSwitchNetworkLoaderToNewTestingSession(m_bundle); WKBundleSetAuthorAndUserStylesEnabled(m_bundle, m_pageGroup, true); WKBundleSetFrameFlatteningEnabled(m_bundle, m_pageGroup, false); WKBundleSetMinimumLogicalFontSize(m_bundle, m_pageGroup, 9); diff --git a/Tools/WebKitTestRunner/InjectedBundle/gtk/AccessibilityControllerGtk.cpp b/Tools/WebKitTestRunner/InjectedBundle/atk/AccessibilityControllerAtk.cpp index 489c9a5c8..53e76dd68 100644 --- a/Tools/WebKitTestRunner/InjectedBundle/gtk/AccessibilityControllerGtk.cpp +++ b/Tools/WebKitTestRunner/InjectedBundle/atk/AccessibilityControllerAtk.cpp @@ -68,25 +68,25 @@ static gboolean axObjectEventListener(GSignalInvocationHint *signalHint, guint n if (!accessible || !ATK_IS_OBJECT(accessible)) return TRUE; - GSignalQuery signal_query; + GSignalQuery signalQuery; GOwnPtr<gchar> signalName; GOwnPtr<gchar> signalValue; - g_signal_query(signalHint->signal_id, &signal_query); + g_signal_query(signalHint->signal_id, &signalQuery); - if (!g_strcmp0(signal_query.signal_name, "state-change")) { + if (!g_strcmp0(signalQuery.signal_name, "state-change")) { signalName.set(g_strdup_printf("state-change:%s", g_value_get_string(¶mValues[1]))); signalValue.set(g_strdup_printf("%d", g_value_get_boolean(¶mValues[2]))); - } else if (!g_strcmp0(signal_query.signal_name, "focus-event")) { + } else if (!g_strcmp0(signalQuery.signal_name, "focus-event")) { signalName.set(g_strdup("focus-event")); signalValue.set(g_strdup_printf("%d", g_value_get_boolean(¶mValues[1]))); - } else if (!g_strcmp0(signal_query.signal_name, "children-changed")) { + } else if (!g_strcmp0(signalQuery.signal_name, "children-changed")) { signalName.set(g_strdup("children-changed")); signalValue.set(g_strdup_printf("%d", g_value_get_uint(¶mValues[1]))); - } else if (!g_strcmp0(signal_query.signal_name, "property-change")) + } else if (!g_strcmp0(signalQuery.signal_name, "property-change")) signalName.set(g_strdup_printf("property-change:%s", g_quark_to_string(signalHint->detail))); else - signalName.set(g_strdup(signal_query.signal_name)); + signalName.set(g_strdup(signalQuery.signal_name)); printAccessibilityEvent(accessible, signalName.get(), signalValue.get()); @@ -103,12 +103,12 @@ void AccessibilityController::logAccessibilityEvents() rootElement(); // Add global listeners for AtkObject's signals. - m_stateChangeListenerId = atk_add_global_event_listener(axObjectEventListener, "Gtk:AtkObject:state-change"); - m_focusEventListenerId = atk_add_global_event_listener(axObjectEventListener, "Gtk:AtkObject:focus-event"); - m_activeDescendantChangedListenerId = atk_add_global_event_listener(axObjectEventListener, "Gtk:AtkObject:active-descendant-changed"); - m_childrenChangedListenerId = atk_add_global_event_listener(axObjectEventListener, "Gtk:AtkObject:children-changed"); - m_propertyChangedListenerId = atk_add_global_event_listener(axObjectEventListener, "Gtk:AtkObject:property-change"); - m_visibleDataChangedListenerId = atk_add_global_event_listener(axObjectEventListener, "Gtk:AtkObject:visible-data-changed"); + m_stateChangeListenerId = atk_add_global_event_listener(axObjectEventListener, "ATK:AtkObject:state-change"); + m_focusEventListenerId = atk_add_global_event_listener(axObjectEventListener, "ATK:AtkObject:focus-event"); + m_activeDescendantChangedListenerId = atk_add_global_event_listener(axObjectEventListener, "ATK:AtkObject:active-descendant-changed"); + m_childrenChangedListenerId = atk_add_global_event_listener(axObjectEventListener, "ATK:AtkObject:children-changed"); + m_propertyChangedListenerId = atk_add_global_event_listener(axObjectEventListener, "ATK:AtkObject:property-change"); + m_visibleDataChangedListenerId = atk_add_global_event_listener(axObjectEventListener, "ATK:AtkObject:visible-data-changed"); // Ensure the Atk interface types are registered, otherwise // the AtkDocument signal handlers below won't get registered. diff --git a/Tools/WebKitTestRunner/InjectedBundle/gtk/AccessibilityUIElementGtk.cpp b/Tools/WebKitTestRunner/InjectedBundle/atk/AccessibilityUIElementAtk.cpp index 659934685..0bfe9ac96 100644 --- a/Tools/WebKitTestRunner/InjectedBundle/gtk/AccessibilityUIElementGtk.cpp +++ b/Tools/WebKitTestRunner/InjectedBundle/atk/AccessibilityUIElementAtk.cpp @@ -35,6 +35,9 @@ #include <wtf/Assertions.h> #include <wtf/gobject/GOwnPtr.h> #include <wtf/gobject/GRefPtr.h> +#include <wtf/text/CString.h> +#include <wtf/text/WTFString.h> +#include <wtf/unicode/CharacterNames.h> namespace WTR { @@ -55,7 +58,7 @@ static gchar* attributeSetToString(AtkAttributeSet* attributeSet) static bool checkElementState(PlatformUIElement element, AtkStateType stateType) { if (!ATK_IS_OBJECT(element)) - return false; + return false; GRefPtr<AtkStateSet> stateSet = adoptGRef(atk_object_ref_state_set(ATK_OBJECT(element))); return atk_state_set_contains_state(stateSet.get(), stateType); @@ -121,6 +124,22 @@ static void alterCurrentValue(PlatformUIElement element, int factor) g_value_unset(¤tValue); } +static gchar* replaceCharactersForResults(gchar* str) +{ + WTF::String uString = WTF::String::fromUTF8(str); + + // The object replacement character is passed along to ATs so we need to be + // able to test for their presence and do so without causing test failures. + uString.replace(objectReplacementCharacter, "<obj>"); + + // The presence of newline characters in accessible text of a single object + // is appropriate, but it makes test results (especially the accessible tree) + // harder to read. + uString.replace("\n", "<\\n>"); + + return g_strdup(uString.utf8().data()); +} + AccessibilityUIElement::AccessibilityUIElement(PlatformUIElement element) : m_element(element) { @@ -406,8 +425,14 @@ JSRetainPtr<JSStringRef> AccessibilityUIElement::orientation() const JSRetainPtr<JSStringRef> AccessibilityUIElement::stringValue() { - // FIXME: implement - return JSStringCreateWithCharacters(0, 0); + if (!m_element || !ATK_IS_TEXT(m_element)) + return JSStringCreateWithCharacters(0, 0); + + GOwnPtr<gchar> text(atk_text_get_text(ATK_TEXT(m_element), 0, -1)); + GOwnPtr<gchar> textWithReplacedCharacters(replaceCharactersForResults(text.get())); + GOwnPtr<gchar> axValue(g_strdup_printf("AXValue: %s", textWithReplacedCharacters.get())); + + return JSStringCreateWithUTF8CString(axValue.get()); } JSRetainPtr<JSStringRef> AccessibilityUIElement::language() diff --git a/Tools/WebKitTestRunner/PlatformWebView.h b/Tools/WebKitTestRunner/PlatformWebView.h index 60d2fc1d5..bbdc6b757 100644 --- a/Tools/WebKitTestRunner/PlatformWebView.h +++ b/Tools/WebKitTestRunner/PlatformWebView.h @@ -89,7 +89,7 @@ public: void setWindowIsKey(bool isKey) { m_windowIsKey = isKey; } bool windowIsKey() const { return m_windowIsKey; } -#if PLATFORM(MAC) +#if PLATFORM(MAC) || PLATFORM(EFL) || PLATFORM(QT) bool viewSupportsOptions(WKDictionaryRef) const; #else bool viewSupportsOptions(WKDictionaryRef) const { return true; } @@ -101,6 +101,9 @@ private: PlatformWKView m_view; PlatformWindow m_window; bool m_windowIsKey; +#if PLATFORM(EFL) || PLATFORM(QT) + bool m_usingFixedLayout; +#endif #if PLATFORM(QT) QEventLoop* m_modalEventLoop; #endif diff --git a/Tools/WebKitTestRunner/StringFunctions.h b/Tools/WebKitTestRunner/StringFunctions.h index 129e7be04..13f6e5853 100644 --- a/Tools/WebKitTestRunner/StringFunctions.h +++ b/Tools/WebKitTestRunner/StringFunctions.h @@ -38,6 +38,7 @@ #include <wtf/OwnArrayPtr.h> #include <wtf/PassOwnArrayPtr.h> #include <wtf/Platform.h> +#include <wtf/text/CString.h> #include <wtf/text/WTFString.h> #include <wtf/Vector.h> @@ -55,6 +56,11 @@ inline WKRetainPtr<WKStringRef> toWK(JSRetainPtr<JSStringRef> string) return toWK(string.get()); } +inline WKRetainPtr<WKStringRef> toWK(const WTF::String& string) +{ + return adoptWK(WKStringCreateWithUTF8CString(string.utf8().data())); +} + inline JSRetainPtr<JSStringRef> toJS(WKStringRef string) { return JSRetainPtr<JSStringRef>(Adopt, WKStringCopyJSString(string)); diff --git a/Tools/WebKitTestRunner/TestController.cpp b/Tools/WebKitTestRunner/TestController.cpp index 2eb635b21..145c27087 100644 --- a/Tools/WebKitTestRunner/TestController.cpp +++ b/Tools/WebKitTestRunner/TestController.cpp @@ -331,7 +331,6 @@ void TestController::initialize(int argc, const char* argv[]) WKContextSetDiskCacheDirectory(m_context.get(), dumpRenderTreeTempWK.get()); WKContextSetCookieStorageDirectory(m_context.get(), dumpRenderTreeTempWK.get()); - std::string iconDatabaseFileTemp(dumpRenderTreeTemp); // WebCore::pathByAppendingComponent is not used here because of the namespace, // which leads us to this ugly #ifdef and file path concatenation. #if OS(WINDOWS) @@ -339,9 +338,8 @@ void TestController::initialize(int argc, const char* argv[]) #else const char separator = '/'; #endif - iconDatabaseFileTemp = iconDatabaseFileTemp + separator + "WebpageIcons.db"; - WKRetainPtr<WKStringRef> iconDatabaseFileTempWK = WKStringCreateWithUTF8CString(iconDatabaseFileTemp.c_str()); - WKContextSetIconDatabasePath(m_context.get(), iconDatabaseFileTempWK.get()); + String iconDatabaseFileTemp = String::fromUTF8(dumpRenderTreeTemp) + separator + String(ASCIILiteral("WebpageIcons.db")); + WKContextSetIconDatabasePath(m_context.get(), toWK(iconDatabaseFileTemp).get()); } platformInitializeContext(); diff --git a/Tools/WebKitTestRunner/TestInvocation.cpp b/Tools/WebKitTestRunner/TestInvocation.cpp index ef17437e4..bad24fa61 100644 --- a/Tools/WebKitTestRunner/TestInvocation.cpp +++ b/Tools/WebKitTestRunner/TestInvocation.cpp @@ -1,5 +1,6 @@ /* * Copyright (C) 2010, 2011, 2012 Apple Inc. All rights reserved. + * Copyright (C) 2012 Intel Corporation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -165,9 +166,31 @@ static void updateTiledDrawingForCurrentTest(const char* pathOrURL) #endif } +#if ENABLE(CSS_DEVICE_ADAPTATION) +static bool shouldUseFixedLayout(const char* pathOrURL) +{ + return strstr(pathOrURL, "device-adapt/") || strstr(pathOrURL, "device-adapt\\"); +} +#endif + +static void updateLayoutType(const char* pathOrURL) +{ +#if ENABLE(CSS_DEVICE_ADAPTATION) + WKRetainPtr<WKMutableDictionaryRef> viewOptions = adoptWK(WKMutableDictionaryCreate()); + WKRetainPtr<WKStringRef> useFixedLayoutKey = adoptWK(WKStringCreateWithUTF8CString("UseFixedLayout")); + WKRetainPtr<WKBooleanRef> useFixedLayoutValue = adoptWK(WKBooleanCreate(shouldUseFixedLayout(pathOrURL))); + WKDictionaryAddItem(viewOptions.get(), useFixedLayoutKey.get(), useFixedLayoutValue.get()); + + TestController::shared().ensureViewSupportsOptions(viewOptions.get()); +#else + UNUSED_PARAM(pathOrURL); +#endif +} + void TestInvocation::invoke() { sizeWebViewForCurrentTest(m_pathOrURL.c_str()); + updateLayoutType(m_pathOrURL.c_str()); updateTiledDrawingForCurrentTest(m_pathOrURL.c_str()); WKRetainPtr<WKStringRef> messageName = adoptWK(WKStringCreateWithUTF8CString("BeginTest")); diff --git a/Tools/WebKitTestRunner/efl/PlatformWebViewEfl.cpp b/Tools/WebKitTestRunner/efl/PlatformWebViewEfl.cpp index cb957d5d9..a55242dc1 100644 --- a/Tools/WebKitTestRunner/efl/PlatformWebViewEfl.cpp +++ b/Tools/WebKitTestRunner/efl/PlatformWebViewEfl.cpp @@ -1,5 +1,6 @@ /* * Copyright (C) 2012 Samsung Electronics + * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -30,11 +31,15 @@ namespace WTR { static Ecore_Evas* initEcoreEvas() { - const char* engine = 0; + Ecore_Evas* ecoreEvas = 0; #if defined(WTF_USE_ACCELERATED_COMPOSITING) && defined(HAVE_ECORE_X) - engine = "opengl_x11"; + const char* engine = "opengl_x11"; + ecoreEvas = ecore_evas_new(engine, 0, 0, 800, 600, 0); + // Graceful fallback to software rendering if evas_gl engine is not available. + if (!ecoreEvas) #endif - Ecore_Evas* ecoreEvas = ecore_evas_new(engine, 0, 0, 800, 600, 0); + ecoreEvas = ecore_evas_new(0, 0, 0, 800, 600, 0); + if (!ecoreEvas) return 0; @@ -44,11 +49,19 @@ static Ecore_Evas* initEcoreEvas() return ecoreEvas; } -PlatformWebView::PlatformWebView(WKContextRef context, WKPageGroupRef pageGroup, WKDictionaryRef /*options*/) +PlatformWebView::PlatformWebView(WKContextRef context, WKPageGroupRef pageGroup, WKDictionaryRef options) { + WKRetainPtr<WKStringRef> useFixedLayoutKey(AdoptWK, WKStringCreateWithUTF8CString("UseFixedLayout")); + m_usingFixedLayout = options ? WKBooleanGetValue(static_cast<WKBooleanRef>(WKDictionaryGetItemForKey(options, useFixedLayoutKey.get()))) : false; + m_window = initEcoreEvas(); Evas* evas = ecore_evas_get(m_window); - m_view = toImpl(WKViewCreate(evas, context, pageGroup)); + + if (m_usingFixedLayout) { + m_view = toImpl(WKViewCreateWithFixedLayout(evas, context, pageGroup)); + evas_object_resize(m_view, 800, 600); + } else + m_view = toImpl(WKViewCreate(evas, context, pageGroup)); ewk_view_theme_set(m_view, THEME_DIR"/default.edj"); m_windowIsKey = false; @@ -116,5 +129,12 @@ WKRetainPtr<WKImageRef> PlatformWebView::windowSnapshotImage() return 0; } +bool PlatformWebView::viewSupportsOptions(WKDictionaryRef options) const +{ + WKRetainPtr<WKStringRef> useFixedLayoutKey(AdoptWK, WKStringCreateWithUTF8CString("UseFixedLayout")); + + return m_usingFixedLayout == (options ? WKBooleanGetValue(static_cast<WKBooleanRef>(WKDictionaryGetItemForKey(options, useFixedLayoutKey.get()))) : false); +} + } // namespace WTR diff --git a/Tools/WebKitTestRunner/mac/TestControllerMac.mm b/Tools/WebKitTestRunner/mac/TestControllerMac.mm index a9e9f3190..3b68a0073 100644 --- a/Tools/WebKitTestRunner/mac/TestControllerMac.mm +++ b/Tools/WebKitTestRunner/mac/TestControllerMac.mm @@ -53,12 +53,10 @@ void TestController::initializeTestPluginDirectory() void TestController::platformRunUntil(bool& done, double timeout) { - // FIXME: No timeout should occur if timeout is equal to m_noTimeout (necessary when running performance tests). - CFAbsoluteTime end = CFAbsoluteTimeGetCurrent() + timeout; - CFDateRef endDate = CFDateCreate(0, end); - while (!done && CFAbsoluteTimeGetCurrent() < end) - [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:(NSDate *)endDate]; - CFRelease(endDate); + NSDate *endDate = (timeout > 0) ? [NSDate dateWithTimeIntervalSinceNow:timeout] : [NSDate distantFuture]; + + while (!done && [endDate compare:[NSDate date]] == NSOrderedDescending) + [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:endDate]; } void TestController::platformInitializeContext() diff --git a/Tools/WebKitTestRunner/qt/PlatformWebViewQt.cpp b/Tools/WebKitTestRunner/qt/PlatformWebViewQt.cpp index e1cce48a5..47d407e50 100644 --- a/Tools/WebKitTestRunner/qt/PlatformWebViewQt.cpp +++ b/Tools/WebKitTestRunner/qt/PlatformWebViewQt.cpp @@ -77,14 +77,19 @@ private: QQuickWebView* m_view; }; -PlatformWebView::PlatformWebView(WKContextRef contextRef, WKPageGroupRef pageGroupRef, WKDictionaryRef /*options*/) - : m_view(new QQuickWebView(contextRef, pageGroupRef)) - , m_window(new WrapperWindow(m_view)) - , m_windowIsKey(true) +PlatformWebView::PlatformWebView(WKContextRef contextRef, WKPageGroupRef pageGroupRef, WKDictionaryRef options) + : m_windowIsKey(true) , m_modalEventLoop(0) { + WKRetainPtr<WKStringRef> useFixedLayoutKey(AdoptWK, WKStringCreateWithUTF8CString("UseFixedLayout")); + m_usingFixedLayout = options ? WKBooleanGetValue(static_cast<WKBooleanRef>(WKDictionaryGetItemForKey(options, useFixedLayoutKey.get()))) : false; + QQuickWebViewExperimental::setFlickableViewportEnabled(m_usingFixedLayout); + + m_view = new QQuickWebView(contextRef, pageGroupRef); m_view->setAllowAnyHTTPSCertificateForLocalHost(true); m_view->componentComplete(); + + m_window = new WrapperWindow(m_view); } PlatformWebView::~PlatformWebView() @@ -172,6 +177,13 @@ bool PlatformWebView::windowShapshotEnabled() return result; } +bool PlatformWebView::viewSupportsOptions(WKDictionaryRef options) const +{ + WKRetainPtr<WKStringRef> useFixedLayoutKey(AdoptWK, WKStringCreateWithUTF8CString("UseFixedLayout")); + + return m_usingFixedLayout == (options ? WKBooleanGetValue(static_cast<WKBooleanRef>(WKDictionaryGetItemForKey(options, useFixedLayoutKey.get()))) : false); +} + } // namespace WTR #include "PlatformWebViewQt.moc" diff --git a/Tools/WebKitTestRunner/qt/main.cpp b/Tools/WebKitTestRunner/qt/main.cpp index 3c9d311c9..ac0ee24a5 100644 --- a/Tools/WebKitTestRunner/qt/main.cpp +++ b/Tools/WebKitTestRunner/qt/main.cpp @@ -122,7 +122,6 @@ int main(int argc, char** argv) WebKit::QtTestSupport::initializeTestFonts(); QCoreApplication::setAttribute(Qt::AA_Use96Dpi, true); - QQuickWebViewExperimental::setFlickableViewportEnabled(false); QApplication app(argc, argv); Launcher launcher(argc, argv); QTimer::singleShot(0, &launcher, SLOT(launch())); diff --git a/Tools/efl/jhbuild.modules b/Tools/efl/jhbuild.modules index 55287880d..04de528ba 100644 --- a/Tools/efl/jhbuild.modules +++ b/Tools/efl/jhbuild.modules @@ -153,11 +153,12 @@ </autotools> <autotools id="harfbuzz" autogen-sh="configure"> - <branch module="software/harfbuzz/release/harfbuzz-0.9.2.tar.bz2" version="0.9.2" - checkoutdir="harfbuzz-0.9.2" + <branch module="software/harfbuzz/release/harfbuzz-0.9.6.tar.bz2" version="0.9.6" + checkoutdir="harfbuzz-0.9.6" repo="freedesktop.org" - hash="sha256:c9b581d6357a32043b84ec78179390b582448de790deb487dfdb90b632dc8558" - md5sum="f1c1a2793b44b4d6613f58cc92caa366"> + hash="sha256:394a849d6061993018754b0cc04110891ad215e3df3f6953b75dcc55a11f9d9b" + md5sum="f3a100a0512c185b211a0deb4790c34c"> + <patch file="harfbuzz-icu-detection-fix.patch" strip="1" /> </branch> </autotools> diff --git a/Tools/efl/patches/harfbuzz-icu-detection-fix.patch b/Tools/efl/patches/harfbuzz-icu-detection-fix.patch new file mode 100644 index 000000000..567e24d6c --- /dev/null +++ b/Tools/efl/patches/harfbuzz-icu-detection-fix.patch @@ -0,0 +1,36 @@ +diff --git a/configure.ac b/configure.ac +index b1948f1..9ae69dd 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -184,6 +184,31 @@ fi + AM_CONDITIONAL(HAVE_ICU_LE, $have_icu_le) + + dnl ========================================================================== ++dnl Fallback to icu-config if ICU pkg-config files could not be found ++dnl ========================================================================== ++ ++if test "$have_icu" != "true"; then ++ AC_PATH_PROG(icu_config, icu-config, no) ++ AC_MSG_CHECKING([for ICU by using icu-config fallback]) ++ if test "$icu_config" != "no"; then ++ # We don't use --cflags as this gives us a lot of things that we don't ++ # necessarily want, like debugging and optimization flags ++ # See man (1) icu-config for more info. ++ ICU_CFLAGS=`$icu_config --cppflags` ++ ICU_LIBS=`$icu_config --ldflags-libsonly --ldflags-layout` ++ AC_SUBST(ICU_CFLAGS) ++ AC_SUBST(ICU_LIBS) ++ AC_DEFINE(HAVE_ICU_LE, 1, [Have ICU Layout Engine library]) ++ AC_DEFINE(HAVE_ICU, 1, [Have ICU library]) ++ AM_CONDITIONAL(HAVE_ICU, true) ++ AM_CONDITIONAL(HAVE_ICU_LE, true) ++ AC_MSG_RESULT([yes]) ++ else ++ AC_MSG_RESULT([no]) ++ fi ++fi ++ ++dnl ========================================================================== + + PKG_CHECK_MODULES(GRAPHITE2, graphite2, have_graphite=true, have_graphite=false) + if $have_graphite; then diff --git a/Tools/gtk/jhbuild.modules b/Tools/gtk/jhbuild.modules index f6e468420..0abf14507 100644 --- a/Tools/gtk/jhbuild.modules +++ b/Tools/gtk/jhbuild.modules @@ -54,10 +54,10 @@ <dep package="fontconfig"/> <dep package="pixman"/> </dependencies> - <branch module="releases/cairo-1.10.2.tar.gz" version="1.10.2" + <branch module="releases/cairo-1.12.8.tar.xz" version="1.12.8" repo="cairographics.org" - hash="sha256:32018c7998358eebc2ad578ff8d8559d34fc80252095f110a572ed23d989fc41" - md5sum="f101a9e88b783337b20b2e26dfd26d5f"> + hash="sha256:8fbb6fc66117ab4100bad830cb4479497e53c6f3facb98bf05c8d298554ebdd9" + md5sum="8b3dcade859c44fb7e56fc68edfe9a45"> </branch> </autotools> diff --git a/Tools/qmake/mkspecs/features/configure.prf b/Tools/qmake/mkspecs/features/configure.prf index 3954a9452..81b6f0ea1 100644 --- a/Tools/qmake/mkspecs/features/configure.prf +++ b/Tools/qmake/mkspecs/features/configure.prf @@ -17,7 +17,8 @@ WEBKIT_TOOLS_CONFIG = \ build_imagediff \ build_test_npapi \ build_testbrowser \ - build_minibrowser + build_minibrowser \ + build_qttestsupport defineTest(runConfigure) { !webkit_configured:!print_defaults { diff --git a/Tools/qmake/mkspecs/features/features.prf b/Tools/qmake/mkspecs/features/features.prf index 0aad66021..0212e7969 100644 --- a/Tools/qmake/mkspecs/features/features.prf +++ b/Tools/qmake/mkspecs/features/features.prf @@ -121,7 +121,7 @@ defineTest(detectFeatures) { } # Gamepad API Support - !contains(QT_CONFIG, no-pkg-config):packagesExist(libudev): WEBKIT_CONFIG += gamepad + packagesExist(libudev): WEBKIT_CONFIG += gamepad # Support for Graphics Surface # GraphicsSurface requires GraphicsContext3D and hence use_3d_graphics @@ -134,6 +134,10 @@ defineTest(detectFeatures) { # Slider Touch is sensible to use when compiling WebKit2 enable?(touch_events): WEBKIT_CONFIG += touch_slider + + # Minibrowser must be able to query for QtTestSupport + build?(qttestsupport): WEBKIT_CONFIG += have_qttestsupport + # ---------------- Sanitize features ------------------- export(WEBKIT_CONFIG) diff --git a/Tools/qmake/mkspecs/features/features.pri b/Tools/qmake/mkspecs/features/features.pri index 1272ece02..05976985a 100644 --- a/Tools/qmake/mkspecs/features/features.pri +++ b/Tools/qmake/mkspecs/features/features.pri @@ -77,9 +77,9 @@ FEATURE_DEFAULTS = \ ENABLE_MEDIA_STATISTICS=0 \ ENABLE_MEDIA_STREAM=0 \ ENABLE_METER_ELEMENT=1 \ - ENABLE_MHTML=0 \ + ENABLE_MHTML=1 \ ENABLE_MICRODATA=0 \ - ENABLE_MUTATION_OBSERVERS=0 \ + ENABLE_MUTATION_OBSERVERS=1 \ ENABLE_NAVIGATOR_CONTENT_UTILS=0 \ ENABLE_NETSCAPE_PLUGIN_API=0 \ ENABLE_NETWORK_INFO=0 \ @@ -87,6 +87,7 @@ FEATURE_DEFAULTS = \ ENABLE_ORIENTATION_EVENTS=0 \ ENABLE_PAGE_VISIBILITY_API=1 \ ENABLE_PROGRESS_ELEMENT=1 \ + ENABLE_PROXIMITY_EVENTS=0 \ ENABLE_QUOTA=0 \ ENABLE_RESOLUTION_MEDIA_QUERY=1 \ ENABLE_REQUEST_ANIMATION_FRAME=1 \ @@ -112,5 +113,5 @@ FEATURE_DEFAULTS = \ ENABLE_WEB_SOCKETS=1 \ ENABLE_WEB_TIMING=1 \ ENABLE_WORKERS=1 \ - ENABLE_XHR_TIMEOUT = 0 \ + ENABLE_XHR_TIMEOUT=1 \ ENABLE_XSLT=0 \ diff --git a/Tools/qmake/mkspecs/features/unix/default_post.prf b/Tools/qmake/mkspecs/features/unix/default_post.prf index 5a73f17d4..8aee30fda 100644 --- a/Tools/qmake/mkspecs/features/unix/default_post.prf +++ b/Tools/qmake/mkspecs/features/unix/default_post.prf @@ -12,7 +12,7 @@ linux-g++*:isEqual(QT_ARCH,i386) { QMAKE_CXXFLAGS += -march=pentium4 -msse2 -mfpmath=sse } -linux-g++* { +linux-*g++* { !production_build { # Treat warnings as errors on x86/Linux/GCC isEqual(QT_ARCH,x86_64)|isEqual(QT_ARCH,i386): QMAKE_CXXFLAGS += -Werror |