diff options
Diffstat (limited to 'comm/mail/test/browser/pref-window/browser_fontChooser.js')
| -rw-r--r-- | comm/mail/test/browser/pref-window/browser_fontChooser.js | 375 |
1 files changed, 375 insertions, 0 deletions
diff --git a/comm/mail/test/browser/pref-window/browser_fontChooser.js b/comm/mail/test/browser/pref-window/browser_fontChooser.js new file mode 100644 index 0000000000..bf75433ec3 --- /dev/null +++ b/comm/mail/test/browser/pref-window/browser_fontChooser.js @@ -0,0 +1,375 @@ +/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* + * Test various things about the font chooser window, including + * - whether if the font defined in font.name.<style>.<language> is not present + * on the computer, we fall back to displaying what's in + * font.name-list.<style>.<language>. + */ + +"use strict"; + +var utils = ChromeUtils.import("resource://testing-common/mozmill/utils.jsm"); +var { content_tab_e } = ChromeUtils.import( + "resource://testing-common/mozmill/ContentTabHelpers.jsm" +); +var { mc } = ChromeUtils.import( + "resource://testing-common/mozmill/FolderDisplayHelpers.jsm" +); +var { close_pref_tab, open_pref_tab } = ChromeUtils.import( + "resource://testing-common/mozmill/PrefTabHelpers.jsm" +); +var { wait_for_frame_load } = ChromeUtils.import( + "resource://testing-common/mozmill/WindowHelpers.jsm" +); + +var { Preferences } = ChromeUtils.importESModule( + "resource://gre/modules/Preferences.sys.mjs" +); + +var gFontEnumerator; +var gTodayPane; + +// We'll test with Western. Unicode has issues on Windows (bug 550443). +const kLanguage = "x-western"; + +// A list of fonts present on the computer for each font type. +var gRealFontLists = {}; + +// A list of font types to consider +const kFontTypes = ["serif", "sans-serif", "monospace"]; + +add_setup(function () { + if (AppConstants.platform == "win") { + Services.prefs.setStringPref( + "font.name-list.serif.x-western", + "bc7e8c62-0634-467f-a029-fe6abcdf1582, Times New Roman" + ); + Services.prefs.setStringPref( + "font.name-list.sans-serif.x-western", + "419129aa-43b7-40c4-b554-83d99b504b89, Arial" + ); + Services.prefs.setStringPref( + "font.name-list.monospace.x-western", + "348df6e5-e874-4d21-ad4b-359b530a33b7, Courier New" + ); + } else if (AppConstants.platform == "macosx") { + Services.prefs.setStringPref( + "font.name-list.serif.x-western", + "bc7e8c62-0634-467f-a029-fe6abcdf1582, Times" + ); + Services.prefs.setStringPref( + "font.name-list.sans-serif.x-western", + "419129aa-43b7-40c4-b554-83d99b504b89, Helvetica" + ); + Services.prefs.setStringPref( + "font.name-list.monospace.x-western", + "348df6e5-e874-4d21-ad4b-359b530a33b7, Courier" + ); + } else { + Services.prefs.setStringPref( + "font.name-list.serif.x-western", + "bc7e8c62-0634-467f-a029-fe6abcdf1582, serif" + ); + Services.prefs.setStringPref( + "font.name-list.sans-serif.x-western", + "419129aa-43b7-40c4-b554-83d99b504b89, sans-serif" + ); + Services.prefs.setStringPref( + "font.name-list.monospace.x-western", + "348df6e5-e874-4d21-ad4b-359b530a33b7, monospace" + ); + } + + let finished = false; + buildFontList().then(() => (finished = true), console.error); + utils.waitFor( + () => finished, + "Timeout waiting for font enumeration to complete." + ); + + // Hide Lightning's Today pane as it obscures buttons in preferences in the + // small TB window our tests run in. + gTodayPane = mc.window.document.getElementById("today-pane-panel"); + if (gTodayPane) { + if (!gTodayPane.collapsed) { + EventUtils.synthesizeKey("VK_F11", {}); + } else { + gTodayPane = null; + } + } +}); + +async function buildFontList() { + gFontEnumerator = Cc["@mozilla.org/gfx/fontenumerator;1"].createInstance( + Ci.nsIFontEnumerator + ); + for (let fontType of kFontTypes) { + gRealFontLists[fontType] = await gFontEnumerator.EnumerateFontsAsync( + kLanguage, + fontType + ); + if (gRealFontLists[fontType].length == 0) { + throw new Error( + "No fonts found for language " + + kLanguage + + " and font type " + + fontType + + "." + ); + } + } +} + +function assert_fonts_equal(aDescription, aExpected, aActual, aPrefix = false) { + if ( + !( + (!aPrefix && aExpected == aActual) || + (aPrefix && aActual.startsWith(aExpected)) + ) + ) { + throw new Error( + "The " + + aDescription + + " font should be '" + + aExpected + + "', but " + + (aActual.length == 0 + ? "nothing is actually selected." + : "is actually: " + aActual + ".") + ); + } +} + +/** + * Verify that the given fonts are displayed in the font chooser. This opens the + * pref window to the display pane and checks that, then opens the font chooser + * and checks that too. + */ +async function _verify_fonts_displayed( + aDefaults, + aSerif, + aSansSerif, + aMonospace +) { + // Bring up the preferences window. + let prefTab = open_pref_tab("paneGeneral"); + let contentDoc = prefTab.browser.contentDocument; + let prefsWindow = contentDoc.ownerGlobal; + prefsWindow.resizeTo(screen.availWidth, screen.availHeight); + + let isSansDefault = + Services.prefs.getCharPref("font.default." + kLanguage) == "sans-serif"; + let displayPaneExpected = isSansDefault ? aSansSerif : aSerif; + let displayPaneActual = content_tab_e(prefTab, "defaultFont"); + utils.waitFor( + () => displayPaneActual.itemCount > 0, + "No font names were populated in the font picker." + ); + assert_fonts_equal( + "display pane", + displayPaneExpected, + displayPaneActual.value + ); + + let advancedFonts = contentDoc.getElementById("advancedFonts"); + advancedFonts.scrollIntoView(false); + // eslint-disable-next-line mozilla/no-arbitrary-setTimeout + await new Promise(resolve => setTimeout(resolve, 500)); + // Now open the advanced dialog. + EventUtils.synthesizeMouseAtCenter(advancedFonts, {}, prefsWindow); + let fontc = wait_for_frame_load( + prefsWindow.gSubDialog._topDialog._frame, + "chrome://messenger/content/preferences/fonts.xhtml" + ); + + // The font pickers are populated async so we need to wait for it. + for (let fontElemId of ["serif", "sans-serif", "monospace"]) { + utils.waitFor( + () => fontc.window.document.getElementById(fontElemId).label != "", + "Timeout waiting for font picker '" + fontElemId + "' to populate." + ); + } + + if (!aDefaults) { + assert_fonts_equal( + "serif", + aSerif, + fontc.window.document.getElementById("serif").value + ); + assert_fonts_equal( + "sans-serif", + aSansSerif, + fontc.window.document.getElementById("sans-serif").value + ); + assert_fonts_equal( + "monospace", + aMonospace, + fontc.window.document.getElementById("monospace").value + ); + } else if (AppConstants.platform == "linux") { + // When default fonts are displayed in the menulist, there is no value set, + // only the label, in the form "Default (font name)". + + // On Linux the prefs we set contained only the generic font names, + // like 'serif', but here a specific font name will be shown, but it is + // system-dependent what it will be. So we just check for the 'Default' + // prefix. + assert_fonts_equal( + "serif", + `Default (`, + fontc.window.document.getElementById("serif").label, + true + ); + assert_fonts_equal( + "sans-serif", + `Default (`, + fontc.window.document.getElementById("sans-serif").label, + true + ); + assert_fonts_equal( + "monospace", + `Default (`, + fontc.window.document.getElementById("monospace").label, + true + ); + } else { + assert_fonts_equal( + "serif", + `Default (${aSerif})`, + fontc.window.document.getElementById("serif").label + ); + assert_fonts_equal( + "sans-serif", + `Default (${aSansSerif})`, + fontc.window.document.getElementById("sans-serif").label + ); + assert_fonts_equal( + "monospace", + `Default (${aMonospace})`, + fontc.window.document.getElementById("monospace").label + ); + } + + close_pref_tab(prefTab); +} + +/** + * Test that for a particular language, whatever's in + * font.name.<type>.<language> is displayed in the font chooser (if it is + * present on the computer). + */ +add_task(async function test_font_name_displayed() { + Services.prefs.setCharPref("font.language.group", kLanguage); + + // Pick the first font for each font type and set it. + let expected = {}; + for (let [fontType, fontList] of Object.entries(gRealFontLists)) { + // Work around bug 698238 (on Windows, Courier is returned by the enumerator but + // substituted with Courier New) by getting the standard (substituted) family + // name for each font. + let standardFamily = gFontEnumerator.getStandardFamilyName(fontList[0]); + Services.prefs.setCharPref( + "font.name." + fontType + "." + kLanguage, + standardFamily + ); + expected[fontType] = standardFamily; + } + + let fontTypes = kFontTypes.map(fontType => expected[fontType]); + await _verify_fonts_displayed(false, ...fontTypes); + teardownTest(); +}); + +// Fonts definitely not present on a computer -- we simply use UUIDs. These +// should be kept in sync with the ones in *-prefs.js. +const kFakeFonts = { + serif: "bc7e8c62-0634-467f-a029-fe6abcdf1582", + "sans-serif": "419129aa-43b7-40c4-b554-83d99b504b89", + monospace: "348df6e5-e874-4d21-ad4b-359b530a33b7", +}; + +/** + * Test that for a particular language, if font.name.<type>.<language> is not + * present on the computer, we fall back to displaying what's in + * font.name-list.<type>.<language>. + */ +add_task(async function test_font_name_not_present() { + Services.prefs.setCharPref("font.language.group", kLanguage); + + // The fonts we're expecting to see selected in the font chooser for + // test_font_name_not_present. + let expected = {}; + for (let [fontType, fakeFont] of Object.entries(kFakeFonts)) { + // Look at the font.name-list. We need to verify that the first font is the + // fake one, and that the second one is present on the user's computer. + let listPref = "font.name-list." + fontType + "." + kLanguage; + let fontList = Services.prefs.getCharPref(listPref); + let fonts = fontList.split(",").map(font => font.trim()); + if (fonts.length != 2) { + throw new Error( + listPref + + " should have exactly two fonts, but it is '" + + fontList + + "'." + ); + } + + if (fonts[0] != fakeFont) { + throw new Error( + "The first font in " + + listPref + + " should be '" + + fakeFont + + "', but is actually: " + + fonts[0] + + "." + ); + } + + if (!gRealFontLists[fontType].includes(fonts[1])) { + throw new Error( + "The second font in " + + listPref + + " (" + + fonts[1] + + ") should be present on this computer, but isn't." + ); + } + expected[fontType] = fonts[1]; + + // Set font.name to be a nonsense name that shouldn't exist. + // font.name-list is handled by wrapper.py. + Services.prefs.setCharPref( + "font.name." + fontType + "." + kLanguage, + fakeFont + ); + } + + let fontTypes = kFontTypes.map(fontType => expected[fontType]); + await _verify_fonts_displayed(true, ...fontTypes); + teardownTest(); +}); + +function teardownTest() { + // nsIPrefBranch.resetBranch() is not implemented in M-C, so we can't use + // Services.prefs.resetBranch(). + Preferences.resetBranch("font.name."); +} + +registerCleanupFunction(function () { + Services.prefs.clearUserPref("font.language.group"); + if (gTodayPane && gTodayPane.collapsed) { + EventUtils.synthesizeKey("VK_F11", {}); + } + + Assert.report( + false, + undefined, + undefined, + "Test ran to completion successfully" + ); +}); |