WebDriverWrapper.java

/*
 * Copyright (c) 2015-2026 LabKey Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.labkey.test;

import org.apache.commons.collections4.MultiValuedMap;
import org.apache.commons.collections4.multimap.HashSetValuedHashMap;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.mutable.MutableInt;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.assertj.core.api.Assertions;
import org.awaitility.Awaitility;
import org.intellij.lang.annotations.Language;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.junit.Assert;
import org.labkey.remoteapi.CommandException;
import org.labkey.remoteapi.Connection;
import org.labkey.remoteapi.GuestCredentialsProvider;
import org.labkey.remoteapi.security.WhoAmICommand;
import org.labkey.remoteapi.security.WhoAmIResponse;
import org.labkey.test.components.html.BootstrapMenu;
import org.labkey.test.components.html.RadioButton;
import org.labkey.test.components.html.SiteNavBar;
import org.labkey.test.components.labkey.LabKeyAlert;
import org.labkey.test.pages.admin.FolderManagementPage;
import org.labkey.test.pages.admin.PermissionsPage;
import org.labkey.test.pages.assay.AssayBeginPage;
import org.labkey.test.pages.core.admin.ProjectSettingsPage;
import org.labkey.test.pages.list.BeginPage;
import org.labkey.test.pages.query.ExecuteQueryPage;
import org.labkey.test.pages.reports.ManageViewsPage;
import org.labkey.test.pages.study.ManageStudyPage;
import org.labkey.test.pages.user.ShowUsersPage;
import org.labkey.test.selenium.EphemeralWebElement;
import org.labkey.test.util.CodeMirrorHelper;
import org.labkey.test.util.Crawler;
import org.labkey.test.util.EscapeUtil;
import org.labkey.test.util.Ext4Helper;
import org.labkey.test.util.ExtHelper;
import org.labkey.test.util.HtmlFragmentSelection;
import org.labkey.test.util.LabKeyExpectedConditions;
import org.labkey.test.util.LogMethod;
import org.labkey.test.util.LoggedParam;
import org.labkey.test.util.OptionalFeatureHelper;
import org.labkey.test.util.PasswordUtil;
import org.labkey.test.util.RelativeUrl;
import org.labkey.test.util.TestLogger;
import org.labkey.test.util.TextSearcher;
import org.labkey.test.util.TextSearcher.TextTransformers;
import org.labkey.test.util.Timer;
import org.labkey.test.util.selenium.JavascriptExecutorWrapper;
import org.labkey.test.util.selenium.ScrollUtils;
import org.labkey.test.util.selenium.WebDriverUtils;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.Capabilities;
import org.openqa.selenium.Cookie;
import org.openqa.selenium.Dimension;
import org.openqa.selenium.HasCapabilities;
import org.openqa.selenium.JavascriptException;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.Keys;
import org.openqa.selenium.NoAlertPresentException;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.NoSuchWindowException;
import org.openqa.selenium.ScriptTimeoutException;
import org.openqa.selenium.SearchContext;
import org.openqa.selenium.StaleElementReferenceException;
import org.openqa.selenium.TimeoutException;
import org.openqa.selenium.UnexpectedAlertBehaviour;
import org.openqa.selenium.UnhandledAlertException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebDriverException;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.WindowType;
import org.openqa.selenium.WrapsDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeDriverService;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.firefox.FirefoxDriverLogLevel;
import org.openqa.selenium.firefox.FirefoxDriverService;
import org.openqa.selenium.firefox.FirefoxOptions;
import org.openqa.selenium.firefox.FirefoxProfile;
import org.openqa.selenium.firefox.GeckoDriverService;
import org.openqa.selenium.ie.InternetExplorerDriver;
import org.openqa.selenium.ie.InternetExplorerDriverService;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.remote.service.DriverService;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.Select;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.awt.*;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Duration;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.Stack;
import java.util.TimeZone;
import java.util.WeakHashMap;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Supplier;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import static org.apache.commons.lang3.StringUtils.trimToNull;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.labkey.test.Locator.tag;
import static org.labkey.test.TestProperties.isScriptCheckEnabled;
import static org.labkey.test.TestProperties.isWebDriverLoggingEnabled;
import static org.labkey.test.WebTestHelper.makeRelativeUrl;
import static org.labkey.test.components.html.RadioButton.RadioButton;
import static org.labkey.test.util.LabKeyExpectedConditions.windowIsPresent;
import static org.openqa.selenium.chrome.ChromeDriverService.CHROME_DRIVER_LOG_PROPERTY;
import static org.openqa.selenium.chrome.ChromeDriverService.CHROME_DRIVER_VERBOSE_LOG_PROPERTY;
import static org.openqa.selenium.firefox.GeckoDriverService.GECKO_DRIVER_LOG_PROPERTY;

public abstract class WebDriverWrapper implements WrapsDriver
{
 public final static int WAIT_FOR_JAVASCRIPT = 10000;
 public final static int WAIT_FOR_PAGE = 60000;

 public int defaultWaitForPage = WAIT_FOR_PAGE;
 public int longWaitForPage = defaultWaitForPage * 5;

 public ExtHelper _extHelper;
 public Ext4Helper _ext4Helper;

 private final Stack<String> _locationStack = new Stack<>();
 private String _savedLocation = null;

 private static final Set<String> _controllerFirstUrls = new HashSet<>();

 static
 {
 // Eliminate noise from org.openqa.selenium.remote.ProtocolHandshake and org.openqa.selenium.interactions.Actions
 if (!isWebDriverLoggingEnabled())
 Logger.getLogger("org.openqa.selenium").setLevel(Level.WARNING);
 }

 public WebDriverWrapper()
 {
 _extHelper = new ExtHelper(this);
 _ext4Helper = new Ext4Helper(this);
 }

 @Contract(pure = true)
 @NotNull
 public final WebDriver getDriver()
 {
 WebDriver driver = getWrappedDriver();
 while (driver instanceof WrapsDriver)
 driver = ((WrapsDriver) driver).getWrappedDriver();
 if (driver == null)
 throw new NullPointerException("WebDriver has not been initialized yet");
 return driver;
 }

 protected Pair<WebDriver, DriverService> createNewWebDriver(BrowserType browserType, File downloadDir)
 {
 return createNewWebDriver(new ImmutablePair<>(null, null), browserType, downloadDir);
 }

 /**
 * Number of minutes to add to convert browser Date to UTC.<br>
 * <em> Note: The sign of this is the opposite of Java's concept of time zone offset </em>
 * @return Actual browser time zone offset in minutes
 */
 public int getWebDriverTimeZoneOffset()
 {
 return Math.toIntExact(executeScript("return new Date().getTimezoneOffset();", Long.class));
 }

 /**
 * Test process might be running in a different time zone from the browser. This method give the number of minutes
 * to add to a system date to convert to the equivalent browser date.
 * <pre>{@code
 * TestDateUtils.diffFromTodaysDate(Calendar.MINUTE, getRelativeTimeZoneOffset())
 * }</pre>
 * A negative value indicates that the browser's time zone is West of the system time zone. Positive is East.
 * @return minute offset of browser's time zone relative to the system's
 */
 public int getRelativeTimeZoneOffset()
 {
 return -(ZoneId.systemDefault().getRules().getOffset(Instant.now()).getTotalSeconds() / 60 + getWebDriverTimeZoneOffset());
 }

 /**
 * Get an unnamed time zone with the browser's offset
 */
 public TimeZone getClientTimeZone()
 {
 return TimeZone.getTimeZone(ZoneOffset.ofTotalSeconds(-getWebDriverTimeZoneOffset() * 60));
 }

 /**
 * Allow tests to disable time zone shifting. Warning: {@link TestProperties#getBrowserZoneId()} might not match actual
 * browser time zone if this is false.
 */
 protected boolean allowTimeZoneShifting()
 {
 return true;
 }

 protected Pair<WebDriver, DriverService> createNewWebDriver(@NotNull Pair<WebDriver, DriverService> oldDriverAndService, BrowserType browserType, File downloadDir)
 {
 WebDriver oldWebDriver = oldDriverAndService.getLeft();
 WebDriver newWebDriver;
 DriverService oldDriverService = oldDriverAndService.getRight();
 DriverService newDriverService;

 Map<String, String> browserEnv = new HashMap<>();
 ZoneId targetBrowserTimeZone = allowTimeZoneShifting() ? TestProperties.getBrowserZoneId() : ZoneId.systemDefault();
 int targetOffsetInSeconds = targetBrowserTimeZone.getRules().getOffset(Instant.now()).getTotalSeconds();

 if (targetBrowserTimeZone != ZoneId.systemDefault())
 {
 browserEnv.put("TZ", targetBrowserTimeZone.toString());
 }

 if (oldWebDriver != null &&
 (!browserType.matchesDriver(oldWebDriver) ||
 new WebDriverWrapperImpl(oldWebDriver).getWebDriverTimeZoneOffset() * -60 != targetOffsetInSeconds))
 {
 TestLogger.info("Quitting existing driver and service");
 oldWebDriver.quit();
 oldWebDriver = null;
 if (oldDriverService != null && oldDriverService.isRunning())
 oldDriverService.stop();
 }

 final Pair<WebDriver, DriverService> result;

 if (oldWebDriver == null)
 {
 log("Starting new browser: " + browserType);

 switch (browserType)
 {
 case REMOTE: //experimental
 {
 try
 {
 newDriverService = null; // Remote service runs independently of tests
 newWebDriver = new RemoteWebDriver(new URL("http://localhost:4444/wd/hub"), new ChromeOptions());
 }
 catch (MalformedURLException e)
 {
 throw new RuntimeException(e);
 }
 break;
 }
 case IE: //experimental
 {
 newDriverService = new InternetExplorerDriverService.Builder().withEnvironment(browserEnv).build();
 newWebDriver = new InternetExplorerDriver((InternetExplorerDriverService) newDriverService);
 break;
 }
 case CHROME:
 {
 configureChromeDriverLogging(downloadDir);
 ChromeOptions options = new ChromeOptions();
 Map<String, Object> prefs = new HashMap<>();

 prefs.put("download.prompt_for_download", "false");
 prefs.put("download.default_directory", downloadDir.getAbsolutePath());
 prefs.put("profile.content_settings.pattern_pairs.*.multiple-automatic-downloads", 1); // Turns off multiple download warning
 prefs.put("security.warn_submit_insecure", "false");
 prefs.put("pdfjs.disabled", true); // Download PDFs
 prefs.put("credentials_enable_service", false);
 prefs.put("profile.password_manager_enabled", false);
 prefs.put("safebrowsing.enabled", false); // Disable "This type of file can harm your computer."
 options.setExperimentalOption("prefs", prefs);
 options.setExperimentalOption("detach", true); // Leaves browser window open after stopping the driver service
 options.addArguments("test-type"); // Suppress '--ignore-certificate-errors' warning
 options.addArguments("disable-xss-auditor");
 options.addArguments("ignore-certificate-errors");
 options.addArguments("disable-infobars");
 options.addArguments("short-reporting-delay");
 if (TestProperties.isRunWebDriverHeadless())
 {
 TestLogger.warn("Launching Chrome in headless mode. This is still experimental");
 options.addArguments("headless");
 }

 newDriverService = new ChromeDriverService.Builder().withEnvironment(browserEnv).build();
 newWebDriver = new ChromeDriver((ChromeDriverService) newDriverService, options);
 break;
 }
 case FIREFOX:
 {
 configureGeckoDriverLogging(downloadDir);
 final FirefoxProfile profile = new FirefoxProfile();
 profile.setPreference("app.update.auto", false);
 profile.setPreference("extensions.update.autoUpdate", false);
 profile.setPreference("extensions.update.enabled", false);
 profile.setPreference("dom.max_script_run_time", 0);
 profile.setPreference("dom.max_chrome_script_run_time", 0);
 //profile.setPreference("dom.reporting.enabled", true); // Enable support for CSP report-to

 // Prevent crawler from hanging on '_print=1' pages
 profile.setPreference("print.always_print_silent", true);
 profile.setPreference("print_printer", "Print to File");
 profile.setPreference("print.print_to_filename", new File(downloadDir, "print.pdf").getAbsolutePath());

 profile.setPreference("browser.download.folderList", 2);
 profile.setPreference("browser.download.downloadDir", downloadDir.getAbsolutePath());
 profile.setPreference("browser.download.dir", downloadDir.getAbsolutePath());
 profile.setPreference("browser.download.manager.showAlertOnComplete", false);
 profile.setPreference("browser.download.manager.showWhenStarting", false);
 profile.setPreference("browser.download.panel.shown", false);
 profile.setPreference("browser.download.viewableInternally.enabledTypes", ""); // Default includes 'xml', which overrides the 'saveToDisk' setting
 profile.setPreference("browser.helperApps.alwaysAsk.force", false);
 profile.setPreference("browser.helperApps.neverAsk.saveToDisk",
 "application/vnd.ms-excel," + // .xls
 "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet," + // .xlsx
 "application/vnd.openxmlformats-officedocument.presentationml.presentation," + // .pptx (power point)
 "application/vnd.openxmlformats-officedocument.wordprocessingml.document," +
 "application/octet-stream," +
 "application/pdf," +
 "application/zip," +
 "application/x-x509-ca-cert," + // .crt, .cer
 "application/x-gzip," +
 "application/x-zip-compressed," +
 "application/xml," +
 "application/json" +
 "image/png," +
 "image/jpeg," +
 "image/tiff," +
 "text/html," +
 "text/plain," +
 "text/xml," +
 "text/x-script.perl," +
 "text/tab-separated-values," +
 "text/csv");
 profile.setPreference("pdfjs.disabled", true); // disable Firefox's built-in PDF viewer
 profile.setPreference("pdfjs.enabledCache.state", false);
 profile.setPreference("widget.gtk.overlay-scrollbars.enabled", false); // Disable mini-scrollbars on Linux

 profile.setPreference("browser.ssl_override_behavior", 0);

 // TODO: Issue 38785: dom.disable_beforeunload FireFox preference is causing numerous test failures
 // profile.setPreference("dom.disable_beforeunload", false);

 profile.setAcceptUntrustedCertificates(true);
 profile.setAssumeUntrustedCertificateIssuer(false);

 FirefoxOptions capabilities = new FirefoxOptions();
 capabilities.setProfile(profile);
 capabilities.setLogLevel(FirefoxDriverLogLevel.WARN);
 capabilities.addPreference("--log", "WARN");

 String browserPath = System.getProperty("selenium.firefox.binary", "");
 if (!browserPath.isEmpty())
 {
 capabilities.setBinary(browserPath);
 }

 if (TestProperties.isRunWebDriverHeadless())
 {
 TestLogger.warn("Launching Firefox in headless mode. This is still experimental");
 capabilities.addArguments("--headless");
 }

 // Firefox 128: UnhandledAlertException doesn't include alert text. Need to leave alerts to get text manually.
 capabilities.setUnhandledPromptBehaviour(UnexpectedAlertBehaviour.IGNORE);
 FirefoxOptions firefoxOptions = new FirefoxOptions(capabilities);

 GeckoDriverService.Builder driverServiceBuilder = new GeckoDriverService.Builder()
 .withEnvironment(browserEnv);

 newDriverService = driverServiceBuilder.build();
 try
 {
 newWebDriver = new FirefoxDriver((FirefoxDriverService) newDriverService, firefoxOptions);
 }
 catch (WebDriverException retry)
 {
 try
 {
 retry.printStackTrace(System.err);
 newDriverService.stop();
 newDriverService = driverServiceBuilder.build();
 sleep(10000);
 newWebDriver = new FirefoxDriver((FirefoxDriverService) newDriverService, firefoxOptions);
 }
 catch (WebDriverException rethrow)
 {
 newDriverService.stop();
 throw new WebDriverException("ERROR: Failed to initialize FirefoxDriver. " +
 "Ensure that you are using compatible versions of Firefox and geckodriver. " +
 "https://firefox-source-docs.mozilla.org/testing/geckodriver/Support.html", rethrow);
 }
 }
 break;
 }
 default:
 {
 throw new IllegalArgumentException("Browser not yet implemented: " + browserType);
 }
 }

 Optional<Dimension> windowSize = TestProperties.getWindowSize();
 if (windowSize.isPresent())
 {
 TestLogger.info("Set window size: " + windowSize.get());
 newWebDriver.manage().window().setSize(windowSize.get());
 }

 result = Pair.of(newWebDriver, newDriverService);
 }
 else
 {
 log("Reusing existing browser");
 result = oldDriverAndService;
 }

 Capabilities caps = ((HasCapabilities) result.getLeft()).getCapabilities();
 String browserName = caps.getBrowserName();
 String browserVersion = caps.getBrowserVersion();
 log("Browser: " + browserName + " " + browserVersion);
 log("Started browser with TZ = " + targetBrowserTimeZone + (targetBrowserTimeZone != ZoneId.systemDefault() ? "" : " (system default)"));
 log(String.format("charset is %s", Charset.defaultCharset().displayName()));

 return result;
 }

 private void configureChromeDriverLogging(File downloadDir)
 {
 if (isWebDriverLoggingEnabled())
 {
 if (downloadDir.getParentFile().exists() || downloadDir.getParentFile().mkdirs())
 {
 String logFileName = new SimpleDateFormat("'chromedriver_'HHmmss'.log'").format(new Date());
 final String logPath = new File(downloadDir.getParentFile(), logFileName).getAbsolutePath();
 log("Saving chromedriver log to: " + logPath);
 System.setProperty(CHROME_DRIVER_VERBOSE_LOG_PROPERTY, "true");
 System.setProperty(CHROME_DRIVER_LOG_PROPERTY, logPath);
 }
 else
 {
 log("Failed to create directory for chromedriver log: " + downloadDir.getParentFile().getAbsolutePath());
 }
 }
 }

 private void configureGeckoDriverLogging(File downloadDir)
 {
 if (isWebDriverLoggingEnabled())
 {
 if (downloadDir.getParentFile().exists() || downloadDir.getParentFile().mkdirs())
 {
 String logFileName = new SimpleDateFormat("'geckodriver_'HHmmss'.log'").format(new Date());
 final String logPath = new File(downloadDir.getParentFile(), logFileName).getAbsolutePath();
 log("Saving geckodriver log to: " + logPath);
 System.setProperty(GECKO_DRIVER_LOG_PROPERTY, logPath);
 return;
 }
 else
 {
 log("Failed to create directory for geckodriver log: " + downloadDir.getParentFile().getAbsolutePath());
 }
 }
 System.setProperty(GECKO_DRIVER_LOG_PROPERTY, "/dev/null");
 }

 public boolean isFirefox()
 {
 return BrowserType.FIREFOX.matchesDriver(getDriver());
 }

 public Object executeScript(@Language("JavaScript") String script, Object... arguments)
 {
 return ((JavascriptExecutor) getDriver()).executeScript(script, arguments);
 }

 /**
 * Wrapper for executing JavaScript through WebDriver and verifying return type.
 * @param <T> See {@link JavascriptExecutor#executeScript(java.lang.String, java.lang.Object...)} for valid return types
 */
 public <T> T executeScript(@Language("JavaScript") String script, Class<T> expectedResultType, Object... arguments)
 {
 return new JavascriptExecutorWrapper(getDriver()).executeScript(script, expectedResultType, arguments);
 }

 /**
 * Wrapper for synchronous execution of asynchronous JavaScript. This wrapper extracts the 'callback' from the argument list
 * See {@link JavascriptExecutor#executeAsyncScript(java.lang.String, java.lang.Object...)} for details
 */
 public Object executeAsyncScript(@Language("JavaScript") String script, Object... arguments)
 {
 return new JavascriptExecutorWrapper(getDriver()).executeAsyncScript(script, arguments);
 }

 public <T> T executeAsyncScript(@Language("JavaScript") String script, Class<T> expectedResultType, Object... arguments)
 {
 return new JavascriptExecutorWrapper(getDriver()).executeAsyncScript(script, expectedResultType, arguments);
 }

 @LogMethod(quiet = true)
 public void resumeJsErrorChecker()
 {
 setJsErrorLogging(true);
 }

 @LogMethod(quiet = true)
 public void pauseJsErrorChecker()
 {
 setJsErrorLogging(false);
 }

 private void setJsErrorLogging(boolean b)
 {
 // Enable/disable server side logging of client errors.
 if (isScriptCheckEnabled())
 {
 WhoAmIResponse whoAmI = whoAmI();
 // Don't use browser session when impersonating. Impersonated user/role might not have correct permission.
 boolean useBrowserSession = PasswordUtil.getUsername().equals(whoAmI.getEmail()) && !whoAmI.isImpersonated();
 Connection cn = WebTestHelper.getRemoteApiConnection(useBrowserSession);
 OptionalFeatureHelper.setOptionalFeature(cn, "javascriptErrorServerLogging", b);
 }
 }

 public enum BrowserType
 {
 REMOTE(null),
 FIREFOX(FirefoxDriver.class),
 IE(InternetExplorerDriver.class),
 CHROME(ChromeDriver.class),
 ;

 private final Class<?> _driverClass;

 BrowserType(Class<?> driverClass)
 {
 _driverClass = driverClass;
 }

 boolean matchesDriver(@NotNull WebDriver oldDriver)
 {
 return _driverClass != null && oldDriver.getClass().isAssignableFrom(_driverClass);
 }
 }

 public static void sleep(long ms)
 {
 try
 {
 Thread.sleep(ms);
 }
 catch (InterruptedException e)
 {
 Thread.currentThread().interrupt();
 throw new IllegalStateException(e);
 }
 }

 public void copyFile(String original, String copy)
 {
 copyFile(new File(original), new File(copy));
 }

 public void copyFile(File original, File copy)
 {
 try
 {
 Files.createDirectories(Paths.get(copy.toURI()).getParent());
 Files.copy(Paths.get(original.toURI()), Paths.get(copy.toURI()),
 StandardCopyOption.COPY_ATTRIBUTES,
 StandardCopyOption.REPLACE_EXISTING);
 }
 catch (IOException e)
 {
 throw new RuntimeException(e);
 }
 }

 public void log(String str)
 {
 str = str.replace(Locator.NOT_HIDDEN, "NOT_HIDDEN"); // This xpath fragment really clutters up the log
 TestLogger.log(str);
 }

 private static final Pattern LABKEY_ERROR_TITLE_PATTERN = Pattern.compile("(\\d\\d\\d)\\D.*Error.*", Pattern.CASE_INSENSITIVE);
 private static final Pattern TOMCAT_ERROR_PATTERN = Pattern.compile("HTTP Status\\s*(\\d\\d\\d)\\D");

 public int getResponseCode()
 {
 //We can't seem to get response codes via javascript, so we rely on default titles for error pages
 String title = getDriver().getTitle();

 Matcher m = LABKEY_ERROR_TITLE_PATTERN.matcher(title);
 if (m.find())
 return Integer.parseInt(m.group(1));

 //Now check the Tomcat page. This is going to be unreliable over time (known to work for Tomcat 7.0 - 9.0)
 m = TOMCAT_ERROR_PATTERN.matcher(getHtmlSource());
 if (m.find())
 return Integer.parseInt(m.group(1));

 if (title.toLowerCase().contains("error") || title.toLowerCase().contains("not found"))
 log("WARNING: Page appears to be an error page but title doesn't match any know pattern: \"" + title + "\"");

 return 200;
 }

 public String getResponseText()
 {
 return getHtmlSource();
 }

 public URL getURL()
 {
 try
 {
 return new URL(getDriver().getCurrentUrl());
 }
 catch (MalformedURLException x)
 {
 throw new RuntimeException("Bad location from selenium tester: " + getDriver().getCurrentUrl(), x);
 }
 }

 @SuppressWarnings("unchecked")
 public List<Pair<String, Map<String, String>>> getLinkAddresses()
 {
 String js = """
 var i, j;
 var addresses = new Array();
 var links = window.document.links;
 for (i = 0; i < links.length; i++) {
 if (links[i].href && links[i].href != '#') {
 //addresses.push({href: links[i].href});
 var link = {href: links[i].href};
 var attributes = new Array();
 for (j = 0; j < links[i].attributes.length; j++)
 {
 // WebDriver can't pass back attributes 'NamedNodeMap'
 let a = links[i].attributes[j];
 attributes.push({name: a.name, value: a.value});
 }
 addresses.push({href: links[i].href, attributes: attributes});
 }
 }
 return addresses;
 """;

 List<Map<String, Object>> linksWithAttributes = (List<Map<String, Object>>) executeScript(js);
 List<Pair<String, Map<String, String>>> links = new ArrayList<>();
 for (Map<String, Object> entry : linksWithAttributes)
 {
 String link = (String) entry.get("href");
 if (link.contains("#"))
 {
 link = link.substring(0, link.indexOf("#"));
 }
 link = trimToNull(link);
 if (null != link)
 {
 Map<String, String> attributes = new HashMap<>();
 List<Map<String, Object>> rawAttributes = (List<Map<String, Object>>) entry.get("attributes");
 if (rawAttributes != null)
 {
 rawAttributes.forEach(att -> attributes.put((String) att.get("name"), (String) att.get("value")));
 }

 links.add(Pair.of(link, attributes));
 }
 }

 return links;
 }

 public List<String> getFormAddresses()
 {
 String js = """
 var i, j;
 var addresses = new Array();
 var forms = window.document.forms;
 for (i = 0; i < forms.length ; i++) {
 var action = forms[i].getAttribute('action'); // raw attribute value
 if (action === 'begin' || action === '#' ||
 ((action === '' || action == undefined) && LABKEY.ActionURL.getAction() === 'begin')) {
 continue;
 }
 action = forms[i].action || window.location.href;
 if (typeof action !== 'string') {
 continue;
 }
 var and = '&';
 if (action.indexOf('?')==-1) {
 and = '?';// No parameters in action, start query string
 }
 for (j=0 ; j<forms[i].elements.length ; j++) {
 if (forms[i].elements[j].name && forms[i].elements[j].name!='X-LABKEY-CSRF') {
 action += and + forms[i].elements[j].name + '=' + (forms[i].elements[j].value || '');
 and = '&';
 }
 }
 addresses.push(action);
 }
 return addresses;
 """;

 return (List<String>) executeScript(js);
 }

 /**
 * Get the relative URL for the current page. The host, port, and context path are removed.
 * @return The relative URL or 'null' if the browser is not currently showing the server under test.
 */
 public String getCurrentRelativeURL()
 {
 URL url = getURL();
 String urlString = getDriver().getCurrentUrl();
 if (80 == WebTestHelper.getWebPort() && url.getAuthority().endsWith(":-1"))
 {
 int portIdx = urlString.indexOf(":-1");
 urlString = urlString.substring(0, portIdx) + urlString.substring(portIdx + (":-1".length()));
 }

 String baseURL = WebTestHelper.getBaseURL();
 if (!urlString.startsWith(baseURL))
 {
 TestLogger.warn("Expected URL to begin with " + baseURL + ", but found " + urlString);
 return null;
 }
 return urlString.substring(baseURL.length());
 }

 public void pushLocation()
 {
 _locationStack.push(getCurrentRelativeURL());
 }

 public void popLocation()
 {
 popLocation(defaultWaitForPage);
 }

 public void popLocation(int millis)
 {
 String location = _locationStack.pop();
 assertNotNull("Cannot pop without a push.", location);
 TestLogger.log("WARNING: pushing/popping locations can be hard to debug, please use beginAt(WebTestHelper.buildURL()) if possible.");
 beginAt(location, millis);
 }

 public void saveLocation()
 {
 _savedLocation = getCurrentRelativeURL();
 }

 public String getSavedLocation()
 {
 return _savedLocation;
 }

 public void recallLocation()
 {
 recallLocation(defaultWaitForPage);
 }

 public void recallLocation(int wait)
 {
 assertNotNull("Cannot recall without saving first.", _savedLocation);
 beginAt(_savedLocation, wait);
 }

 public void refresh()
 {
 refresh(defaultWaitForPage);
 }

 public void refresh(int millis)
 {
 doAndWaitForPageToLoad(() -> {
 try
 {
 getDriver().navigate().refresh();
 }
 catch (TimeoutException ex)
 {
 throw new TestTimeoutException(ex); // Triggers thread dump.
 }
 }, millis);
 }

 public void goBack(int millis)
 {
 doAndWaitForPageToLoad(() -> {
 try
 {
 getDriver().navigate().back();
 }
 catch (TimeoutException ex)
 {
 throw new TestTimeoutException(ex); // Triggers thread dump.
 }
 }, millis);
 }

 public void goBack()
 {
 goBack(defaultWaitForPage);
 }

 public void clickAdminMenuItem(String... items)
 {
 new SiteNavBar(getDriver()).clickAdminMenuItem(true, items);
 }

 public void clickUserMenuItem(String... items)
 {
 clickUserMenuItem(true, items);
 }

 public void clickUserMenuItem(boolean wait, String... items)
 {
 new SiteNavBar(getDriver()).clickUserMenuItem(wait, items);
 }

 /**
 * @deprecated Use {@link BootstrapMenu}
 */
 @Deprecated(since = "22.1")
 @LogMethod(quiet = true)
 public WebElement clickMenuButton(boolean wait, WebElement menu, boolean onlyOpen, @LoggedParam String ... subMenuLabels)
 {
 menu.click();
 try
 {
 waitForElement(BootstrapMenu.Locators.menuItem(subMenuLabels[0]).notHidden(), 1000);
 }
 catch (NoSuchElementException retry)
 {
 menu.click(); // Sometimes ext4 menus don't open on the first try
 waitForElement(BootstrapMenu.Locators.menuItem(subMenuLabels[0]).notHidden(), 1000);
 }
 if (onlyOpen && subMenuLabels.length == 0)
 return null;

 for (int i = 0; i < subMenuLabels.length - 1; i++)
 {
 WebElement subMenuItem = waitForElement(BootstrapMenu.Locators.menuItem(subMenuLabels[i]).notHidden(), 2000);
 clickAndWait(subMenuItem, 0);
 }
 WebElement item = waitForElement(BootstrapMenu.Locators.menuItem(subMenuLabels[subMenuLabels.length - 1]).notHidden());
 if (onlyOpen)
 {
 mouseOver(item);
 return item;
 }

 if (wait)
 clickAndWait(item);
 else
 clickAndWait(item, 0);
 return null;
 }

 // Click on a module listed on the admin menu;
 public void goToModule(String moduleName)
 {
 new SiteNavBar(getDriver()).goToModule(moduleName);
 }

 public void goToSchemaBrowser()
 {
 goToModule("Query");
 shortWait().until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector("div.lk-sb-instructions")));
 waitForElement(Locators.pageSignal("queryTreeRendered"));
 }

 public void goToSchemaBrowser(int waitMilSec)
 {
 goToModule("Query");
 new WebDriverWait(getDriver(), Duration.ofMillis(waitMilSec)).until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector("div.lk-sb-instructions")));
 waitForElement(Locators.pageSignal("queryTreeRendered"), waitMilSec);
 }

 public FolderManagementPage goToFolderManagement()
 {
 clickAdminMenuItem("Folder", "Management");
 return new FolderManagementPage(getDriver());
 }

 public PermissionsPage goToFolderPermissions()
 {
 clickAdminMenuItem("Folder", "Permissions");
 return new PermissionsPage(getDriver());
 }

 public ProjectSettingsPage goToProjectSettings()
 {
 clickAdminMenuItem("Folder", "Project Settings");
 return new ProjectSettingsPage(getDriver());
 }

 public ShowUsersPage goToProjectUsers()
 {
 clickAdminMenuItem("Folder", "Project Users");
 return new ShowUsersPage(getDriver());
 }

 public ShowUsersPage goToSiteUsers()
 {
 if (!isElementPresent(Locator.id("labkey-nav-trail-current-page").withText("Site Users")))
 clickAdminMenuItem("Site", "Site Users");
 return new ShowUsersPage(getDriver());
 }

 public void goToSiteGroups()
 {
 if (!isElementPresent(tag("a").withClass("x4-tab-active").withText("Site Groups")))
 clickAdminMenuItem("Site", "Site Groups");
 // Wait for groups grid
 shortWait().until(ExpectedConditions.visibilityOfElementLocated(Locator.tagWithClass("div", "pSite").withText("Guests")));
 }

 public void goToSitePermissions()
 {
 if (!isElementPresent(tag("a").withClass("x4-tab-active").withText("Site Permissions")))
 clickAdminMenuItem("Site", "Site Permissions");
 }

 public ManageViewsPage goToManageViews()
 {
 clickAdminMenuItem("Manage Views");
 waitForElement(Locator.xpath("//*[starts-with(@id, 'dataviews-panel')]"));
 _extHelper.waitForLoadingMaskToDisappear(WAIT_FOR_JAVASCRIPT);
 return new ManageViewsPage(getDriver());
 }

 public ManageStudyPage goToManageStudy()
 {
 clickAdminMenuItem("Manage Study");
 return new ManageStudyPage(getDriver());
 }

 public AssayBeginPage goToManageAssays()
 {
 clickAdminMenuItem("Manage Assays");
 return new AssayBeginPage(getDriver());
 }

 public BeginPage goToManageLists()
 {
 clickAdminMenuItem("Manage Lists");
 return new BeginPage(getDriver());
 }

 public void goToCreateProject()
 {
 clickAdminMenuItem("Site", "Create Project");
 }


 /**
 * Switch to the initial test window
 */
 public void switchToMainWindow()
 {
 switchToWindow(0);
 }

 public void switchToWindow(int index)
 {
 waitFor(() -> getDriver().getWindowHandles().size() > index, WAIT_FOR_JAVASCRIPT);
 List<String> windows = new ArrayList<>(getDriver().getWindowHandles());
 try
 {
 getDriver().switchTo().window(windows.get(index));
 Awaitility.await("waiting for document to be ready").atMost(Duration.ofMillis(WAIT_FOR_PAGE)).untilAsserted(() ->
 Assertions.assertThat(executeScript("return document.readyState;"))
 .as("document.readyState").isIn("complete", "uninitialized")); // "uninitialized" for blank firefox tab
 }
 catch (StackOverflowError soe)
 {
 // Try to get info for troubleshooting WebDriver issue
 // https://github.com/SeleniumHQ/selenium/issues/6081
 throw new RuntimeException("Internal WebDriver error attempting to switch to window '" +
 windows.get(index) + "'. Available windows: " + windows, soe);
 }
 }

 @LogMethod
 protected void closeExtraWindows()
 {
 List<String> windows = new ArrayList<>(getDriver().getWindowHandles());
 for (int i = 1; i < windows.size(); i++)
 {
 getDriver().switchTo().window(windows.get(i));
 try
 {
 getDriver().close();
 }
 catch (UnhandledAlertException uae)
 {
 Optional.ofNullable(getAlertIfPresent()).ifPresent(Alert::accept);
 }
 }
 if (windows.size() > 1)
 {
 getDriver().switchTo().window(windows.getFirst());
 }
 }

 public boolean isPageEmpty()
 {
 //IE and Firefox have different notions of empty.
 //IE returns html for all pages even empty text...
 String text = getHtmlSource();
 if (null == text || text.trim().isEmpty())
 return true;

 text = getBodyText();
 return null == text || text.trim().isEmpty();
 }

 /**
 * Get rendered, visible page text.
 * @return All visible text from the 'body' of the page
 */
 public String getBodyText()
 {
 ExecutorService executor = Executors.newSingleThreadExecutor();
 CallableGetText getText = new CallableGetText();
 Future<String> future = executor.submit(getText);

 try
 {
 return future.get(60, TimeUnit.SECONDS);
 }
 catch (java.util.concurrent.TimeoutException | InterruptedException | ExecutionException e)
 {
 throw new RuntimeException("Timed out getting page text. Page is probably too complex. Refactor test to look for specific element(s) instead.", e);
 }
 finally
 {
 executor.shutdownNow();
 }
 }

 /**
 * Get page text using a separate thread to avoid test timeouts when complex pages choke WebDriver
 */
 private class CallableGetText implements Callable<String>
 {
 @Override
 public String call()
 {
 try
 {
 return shortWait().until(ExpectedConditions.presenceOfElementLocated(By.cssSelector("body"))).getText();
 }
 catch (TimeoutException |NoSuchElementException tex)
 {
 return getDriver().getPageSource(); // probably viewing a tsv or text file
 }
 }
 }

 @Contract(pure = true)
 public WebDriverWait quickWait()
 {
 return new WebDriverWait(getDriver(), Duration.ofSeconds(1));
 }

 @Contract(pure = true)
 public WebDriverWait shortWait()
 {
 return new WebDriverWait(getDriver(), Duration.ofSeconds(10));
 }

 @Contract(pure = true)
 public WebDriverWait longWait()
 {
 return new WebDriverWait(getDriver(), Duration.ofSeconds(30));
 }

 /**
 * Create a Java API connection, copying the session from the Selenium browser window
 * Use {@link WebTestHelper#getRemoteApiConnection()} to get a connection using 'BasicAuth'.
 */
 public Connection createDefaultConnection()
 {
 Connection connection = new Connection(WebTestHelper.getBaseURL(), new GuestCredentialsProvider());

 Set<Cookie> cookies = getDriver().manage().getCookies();
 for (Cookie cookie : cookies)
 {
 connection.addCookie(cookie.getName(), cookie.getValue(), cookie.getDomain(), cookie.getPath(), cookie.getExpiry(), cookie.isSecure());
 }
 return connection;
 }

 /**
 * @deprecated Copying the browser session is preferred unless tests have specific needs otherwise.
 * Use {@link WebTestHelper#getRemoteApiConnection(boolean)} to get a fresh Connection.
 *
 * @param reuseSession ignored
 * @return A new remoteapi connection matching the current browser session
 */
 @Deprecated
 public Connection createDefaultConnection(boolean reuseSession)
 {
 return createDefaultConnection();
 }

 // Exempt the provided URL from controller-first URL warnings and exceptions
 public void allowControllerFirstUrl(String url)
 {
 _controllerFirstUrls.add(url);
 }

 public long beginAt(String url)
 {
 return beginAt(url, defaultWaitForPage);
 }

 public long beginAtAcceptingAlerts(String url)
 {
 return beginAt(url, defaultWaitForPage, true);
 }

 public long beginAt(String url, int millis)
 {
 return beginAt(url, millis, false);
 }

 public long beginAt(String url, int millis, boolean acceptAlerts)
 {
 String relativeURL = makeRelativeUrl(url);
 String logMessage = "";

 try
 {
 if (relativeURL.isEmpty())
 logMessage = "Navigating to root";
 else
 {
 relativeURL = "/" + relativeURL;
 logMessage = "Navigating to " + relativeURL;
 }

 try
 {
 if (new Crawler.ControllerActionId(relativeURL).isControllerFirstUrl() && !_controllerFirstUrls.contains(url))
 {
 _controllerFirstUrls.add(url);
 RuntimeException ex = new RuntimeException("Controller-first url used: " + relativeURL);
 if (TestProperties.isControllerFirstUrlFatal())
 throw ex;
 else
 TestLogger.log().warn(ex.getMessage(), ex);
 }
 }
 catch (IllegalArgumentException e)
 {
 TestLogger.warn("Unable to parse URL: " + relativeURL, e);
 }

 final String fullURL = WebTestHelper.getBaseURL() + relativeURL;
 final boolean expectPageLoad = expectPageLoad(fullURL);

 long elapsedTime = doAndWaitForPageToLoad(() -> {
 try
 {
 mouseOut();
 getDriver().navigate().to(fullURL);
 }
 catch (TimeoutException ex)
 {
 throw new TestTimeoutException(ex); // Triggers thread dump.
 }
 catch (UnhandledAlertException uae)
 {
 Alert alert;
 if (acceptAlerts && (alert = getAlertIfPresent()) != null)
 {
 TestLogger.warn("Unhandled alert: " + alert.getText());
 alert.accept();
 }
 else
 {
 throw uae;
 }
 }
 }, expectPageLoad ? millis : 0);
 logMessage += TestLogger.formatElapsedTime(elapsedTime);


 return elapsedTime;
 }
 finally
 {
 log(logMessage); // log after navigation to
 }
 }

 /**
 * Navigating within an app will not trigger a page load.
 * Compare current page URL with destination to determine whether to expect a page load.
 */
 private boolean expectPageLoad(String destinationUrl)
 {
 String appAction = "app";
 try
 {
 String currentUrl = getDriver().getCurrentUrl();
 String destinationAction = new Crawler.ControllerActionId(destinationUrl).getAction();
 String currentSansHash = EscapeUtil.decodeUriPath(currentUrl.split("#", 2)[0]);
 String destinationSansHash = EscapeUtil.decodeUriPath(destinationUrl.split("#", 2)[0]);

 return !destinationAction.equals(appAction) ||
 !destinationUrl.contains("#") || // Will always navigate if there is no hash
 !destinationSansHash.equals(currentSansHash);
 }
 catch (IllegalArgumentException bustedUrl)
 {
 // this will happen when the url looks like 'about:blank', or where there isn't a folder or action to
 // parse from the URL
 return true;
 }
 }

 /**
 * @deprecated Use {@link #beginAt(String, int)}
 */
 @Deprecated (since = "22.9")
 public long goToURL(final URL url, int milliseconds)
 {
 return beginAt(url.toString(), milliseconds);
 }

 public ExecuteQueryPage navigateToQuery(String schemaName, String queryName)
 {
 return navigateToQuery(schemaName, queryName, null);
 }

 public ExecuteQueryPage navigateToQuery(String schemaName, String queryName, Integer msTimeout)
 {
 return ExecuteQueryPage.getPageFactory(schemaName, queryName).navigate(this, msTimeout);
 }

 public void navigateToMetadataQuery(String schemaName, String queryName)
 {
 navigateToMetadataQuery(schemaName, queryName, null);
 }

 public void navigateToMetadataQuery(String schemaName, String queryName, Integer msTimeout)
 {
 RelativeUrl queryURL = new RelativeUrl("query", "metadataQuery");
 queryURL.setContainerPath(getCurrentContainerPath());
 queryURL.addParameter("schemaName", schemaName);
 queryURL.addParameter("queryName", queryName);
 queryURL.setTimeout(msTimeout);

 queryURL.navigate(this);
 }

 // Get the container id of the current page
 public String getContainerId()
 {
 return (String)executeScript("return LABKEY.container.id;");
 }

 public String getCurrentContainer()
 {
 return (String)executeScript("return LABKEY.container.name;");
 }

 public String getContainerId(String url)
 {
 pushLocation();
 beginAt(url);
 String containerId = getContainerId();
 popLocation();
 return containerId;
 }

 public String getCurrentProject()
 {
 String[] splitPath = getCurrentContainerPath().split("/");
 for (String pathElement : splitPath)
 {
 if (!pathElement.isEmpty())
 return pathElement;
 }
 return "/"; //root
 }

 @Contract(pure = true)
 public String getCurrentContainerPath()
 {
 return (String) executeScript("return LABKEY.container.path;");
 }

 public WhoAmIResponse whoAmI()
 {
 try
 {
 return new WhoAmICommand().execute(createDefaultConnection(), "/");
 }
 catch (IOException | CommandException e)
 {
 throw new RuntimeException("Failed to fetch current user info.", e);
 }
 }

 public String getCurrentUser()
 {
 return whoAmI().getEmail();
 }

 public String getCurrentUserName()
 {
 return getDisplayName();
 }

 // Return display name for the current logged in user (or impersonated user)
 public String getDisplayName()
 {
 return whoAmI().getDisplayName();
 }

 public int getCurrentUserId()
 {
 return whoAmI().getUserId().intValue();
 }

 public String getCurrentDateTimeFormatString()
 {
 return (String)executeScript("return LABKEY.container.formats.dateTimeFormat");
 }

 public String getCurrentTimeFormatString()
 {
 return (String)executeScript("return LABKEY.container.formats.timeFormat");
 }

 public String getCurrentDateFormatString()
 {
 return (String)executeScript("return LABKEY.container.formats.dateFormat");
 }

 public boolean onLabKeyPage()
 {
 return new LabKeyExpectedConditions.BooleanWait<>(shortWait())
 .until(ignored -> executeScript("return window.LABKEY != undefined;", Boolean.class));
 }

 public boolean onLabKeyClassicPage()
 {
 return onLabKeyPage() && Locator.byClass("lk-header-ct").existsIn(getDriver()); // Single-page apps don't have 'lk-header-ct'
 }

 public boolean isSignedIn()
 {
 return whoAmI().getUserId().longValue() > 0;
 }

 public boolean isUserSystemAdmin()
 {
 return (Boolean)executeScript("return LABKEY.user.isSystemAdmin;");
 }

 public boolean isUserAdmin()
 {
 return (Boolean)executeScript("return LABKEY.user.isAdmin;");
 }

 public boolean isSignedInAsPrimaryTestUser()
 {
 return PasswordUtil.getUsername().equals(getCurrentUser());
 }

 public boolean isImpersonating()
 {
 return whoAmI().isImpersonated();
 }

 public void assertSignedInNotImpersonating()
 {
 assertTrue("Not signed in", isSignedIn());
 assertFalse("Impersonating", isImpersonating());
 assertElementPresent(SiteNavBar.Locators.userMenu);
 }

 public boolean isOnServerErrorPage()
 {
 return isElementPresent(Locator.css("body > table.server-error"));
 }

 public void assertAlert(String msg)
 {
 Alert alert = waitForAlert();
 assertEquals("Wrong alert text", msg, alert.getText());
 alert.accept();
 }

 public void assertAlertIgnoreCaseAndSpaces(String msg)
 {
 Alert alert = waitForAlert();
 String alertTxt, expectedTxt;
 alertTxt = alert.getText().replace(" ", "");
 expectedTxt = msg.replace(" ", "");
 if(!alertTxt.equalsIgnoreCase(expectedTxt))
 Assert.fail("Wrong alert text. Expected '" + msg + "' Actual '" + alert.getText() + "'.");
 alert.accept();
 }

 public void assertAlertContains(String partialMessage)
 {
 Alert alert = waitForAlert();
 String alertText = alert.getText();
 assertTrue("Wrong alert text: " + alertText + ", expected: " + partialMessage, alertText.contains(partialMessage));
 alert.accept();
 }

 public int dismissAllAlerts()
 {
 int alertCount = 0;
 while (alertCount < 10)
 {
 try
 {
 Alert alert = getDriver().switchTo().alert();
 log("Found unexpected alert: " + getAlertText(alert));
 alert.dismiss();
 alertCount++;
 }
 catch (NoAlertPresentException done)
 {
 break;
 }
 }
 getDriver().switchTo().defaultContent();
 if (alertCount == 10)
 {
 throw new IllegalStateException("Too many alerts. Alert loop in JavaScript?");
 }
 return alertCount;
 }

 private String getAlertText(Alert alert)
 {
 try
 {
 return alert.getText();
 }
 catch (RuntimeException e)
 {
 return "Failed to get alert text: " + e.getMessage();
 }
 }

 public Alert getAlertIfPresent()
 {
 try
 {
 return getDriver().switchTo().alert();
 }
 catch (NoAlertPresentException ex)
 {
 return null;
 }
 }

 public String acceptAlert()
 {
 Alert alert = waitForAlert();
 String text = alert.getText();
 alert.accept();
 TestLogger.log("Accepted alert: " + text);
 return text;
 }

 public String cancelAlert()
 {
 Alert alert = waitForAlert();
 String text = alert.getText();
 alert.dismiss();
 TestLogger.log("Dismissed alert: " + text);
 return text;
 }

 protected Alert waitForAlert()
 {
 waitFor(() -> null != getAlertIfPresent(), WAIT_FOR_JAVASCRIPT);
 return getDriver().switchTo().alert();
 }

 public void waitForAlert(String alertText, int wait)
 {
 waitFor(() -> null != getAlertIfPresent(), "No alert appeared.", wait);
 assertAlert(alertText);
 }

 public void assertExtMsgBox(String title, String text, String buttonToClick)
 {
 String actual = _extHelper.getExtMsgBoxText(title);
 assertTrue("Expected Ext.Msg box text '" + text + "', actual '" + actual + "'", actual.contains(text));
 clickButton(buttonToClick, 0);
 }

 public void assertExt4MsgBox(String bodyText, String buttonToClick)
 {
 waitForElement(Locator.css(".x4-window div").withText(bodyText));
 clickButton(buttonToClick, 0);
 }

 public String acceptModalAlert()
 {
 Alert alert = new LabKeyAlert(getDriver());
 String bodyText = alert.getText();
 alert.accept();
 return bodyText;
 }

 public enum SeleniumEvent
 {blur,change,mousedown,mouseup,click,reset,select,submit,abort,error,load,mouseout,mouseover,unload,keyup,focus}

 /**
 * Create and fire a JavaScript UIEvent
 * @param l event target
 * @param event event
 */
 public void fireEvent(Locator l, SeleniumEvent event)
 {
 fireEvent(l.findElement(getDriver()), event);
 }

 /**
 * Create and fire a JavaScript UIEvent
 * @param el event target
 * @param event event
 */
 public void fireEvent(WebElement el, SeleniumEvent event)
 {
 executeScript("""
 var element = arguments[0];
 var eventType = arguments[1];
 var myEvent = document.createEvent('UIEvent');
 myEvent.initEvent(
 eventType, /* event type */
 true, /* can bubble? */
 true /* cancelable? */
 );
 element.dispatchEvent(myEvent);""", el, event.toString());
 }

 public void assertTitleEquals(String match)
 {
 assertEquals("Wrong page title", match, getDriver().getTitle());
 }

 public void assertTitleContains(String match)
 {
 String title = getDriver().getTitle();
 assertTrue("Page title: '" + title + "' doesn't contain '" + match + "'", title.contains(match));
 }

 public void assertNoLabKeyErrors()
 {
 List<WebElement> errors = Locators.labkeyError.findElements(getDriver());

 for (WebElement error : errors)
 {
 String errorText = error.getText();
 if (!errorText.isEmpty())
 fail("Unexpected error found: " + errorText);
 }
 }

 public void assertLabKeyErrorPresent()
 {
 List<WebElement> errors = Locators.labkeyError.findElements(getDriver());

 for (WebElement error : errors)
 {
 if (!error.getText().isEmpty())
 return;
 }
 fail("No errors found");
 }

 /**
 * Check whether all the specified text is present on the page
 * @param texts un-encoded text to search for
 * @return true if all the specified texts are present on the page
 */
 public boolean isTextPresent(String... texts)
 {
 return new TextSearcher(this).areAllTextsPresent(texts);
 }

 /**
 * Check whether the HTML-encoded text is in the page source
 * @param htmlFragments encoded html fragments to search for
 * @return true if all the specified texts are present on the page
 */
 public boolean isHtmlPresent(String... htmlFragments)
 {
 TextSearcher searcher = new TextSearcher(this);
 searcher.setSearchTransformer(TextTransformers.IDENTITY);

 return searcher.areAllTextsPresent(htmlFragments);
 }

 public List<String> getTextOrder(TextSearcher searcher, String... texts)
 {
 final List<Pair<String, Integer>> foundTexts = new ArrayList<>();

 TextSearcher.TextHandler handler = (textSource, text) -> {
 if (textSource.contains(text))
 foundTexts.add(new ImmutablePair<>(text, textSource.indexOf(text)));
 return true;
 };

 searcher.searchForTexts(handler, Arrays.asList(texts));

 List<String> orderedTexts = new ArrayList<>();
 foundTexts.stream()
 .sorted(Map.Entry.comparingByValue())
 .forEachOrdered((pair) -> orderedTexts.add(pair.getKey()));

 return orderedTexts;
 }

 public String getText(Locator elementLocator)
 {
 WebElement el = elementLocator.findElement(getDriver());
 return el.getText();
 }

 public List<String> getTexts(List<WebElement> elements)
 {
 List<String> texts = new ArrayList<>();

 for (WebElement el : elements)
 {
 texts.add(el.getText());
 }

 return texts;
 }

 /**
 * Verifies that all the strings are present in the page html source
 */
 public void assertTextPresent(String... texts)
 {
 assertTextPresent(new TextSearcher(this), texts);
 }

 public void assertTextPresent(TextSearcher searcher, String... texts)
 {
 List<String> missingTexts = searcher.getMissingTexts(texts);

 if (!missingTexts.isEmpty())
 {
 String failMsg = (missingTexts.size() == 1 ? "Text '" : "Texts ['") + String.join("', '", missingTexts) + "'";
 failMsg += missingTexts.size() == 1 ? " was not present" : "] were not present";
 fail(failMsg);
 }
 }

 /**
 * Verifies that all the strings are present in the page html source, disregards casing discrepancies
 */
 public void assertTextPresentCaseInsensitive(String... texts)
 {
 TextSearcher searcher = new TextSearcher(this);

 searcher.setSearchTransformer(TextTransformers.ENCODE_HTML.andThen(String::toLowerCase));

 searcher.setSourceTransformer(String::toLowerCase);

 assertTextPresent(searcher, texts);
 }

 /**
 * Checks whether any of the texts are present in the page source
 */
 public boolean isAnyTextPresent(String... texts)
 {
 return new TextSearcher(this).isAnyTextPresent(texts);
 }

 /**
 * Verifies that at least one of the strings is present in the page html source
 */
 public void assertOneOfTheseTextsPresent(String... texts)
 {
 assertTrue("Did not find any of the following values on current page " + Arrays.toString(texts), isAnyTextPresent(texts));
 }

 /**
 * Verifies that all the strings are present in the page html source
 */
 public void assertTextPresent(List<String> texts)
 {
 String[] textsArray = {};
 textsArray = texts.toArray(textsArray);
 assertTextPresent(textsArray);
 }

 public void assertTextPresentCaseInsensitive(List<String> texts)
 {
 String[] textsArray = {};
 textsArray = texts.toArray(textsArray);
 assertTextPresentCaseInsensitive(textsArray);
 }

 //takes the arguments used to set a filter and transforms them into the description in the grid view
 //then verifies that this description is present
 public void assertFilterTextPresent(String column, String type, String value)
 {
 String desc = type + value;
 String closeParenthesis = ")";
 if(type.contains("Equals One Of"))
 {
 desc = column + " IS ONE OF (" + value.replace(";", ", ") + closeParenthesis;
 }
 else if(type.contains("Contains One Of"))
 {
 desc = column + " CONTAINS ONE OF (" + value.replace(";", ", ") + closeParenthesis;
 }
 else if(type.contains("Does Not Equal Any Of"))
 {
 desc = column + " IS NOT ANY OF (" + value.replace(";", ", ") + closeParenthesis;
 }
 else if(type.contains("Does Not Contain Any Of"))
 {
 desc = column + " DOES NOT CONTAIN ANY OF (" + value.replace(";", ", ") + closeParenthesis;
 }
 else if(type.equals("Equals"))
 {
 desc = column + " = " + value;
 }
 else if(type.contains("Start") || type.contains("Contain")) //Starts With, Does Not Start With, Contains, Does not Contain
 {
 desc = column + " " + type.toUpperCase() + " " + value;
 }
 else if(type.equals("Does Not Equal"))
 {
 desc = column + " <> " + value;
 }
 else if(type.contains("Greater"))
 {
 desc = column + " >";
 if(type.contains("Equal To"))
 desc+="=";
 desc += " " + value;
 }
 else if(type.contains("Less"))
 {
 desc = column + " <";
 if(type.contains("Equal To"))
 desc+="=";
 desc += " " + value;
 }
 else if(type.contains("Is Blank"))
 {
 desc = column + " is blank";
 }
 else if(type.contains("Is Not Blank"))
 {
 desc = column + " is not blank";
 }

 assertTextPresent(desc);

 }

 public void assertTextPresent(String text, int amount)
 {
 assertEquals("Text '" + text + "' was not present the correct number of times", amount, countText(text));
 }

 public void assertTextPresent(TextSearcher searcher, String text, int amount)
 {
 assertEquals("Text '" + text + "' was not present the correct number of times", amount, countText(searcher, text));
 }

 public int countText(String text)
 {
 text = text.replace("&nbsp;", " ");
 String html = getHtmlSource();
 // Strip all JavaScript tags; in particular, the selenium-injected javascript tag, which can foul up the expected occurrences
 String source = html.replaceAll("(?msi)<script type=\"text/javascript\">.*?</script>", "");
 int current_index = 0;
 int count = 0;

 while ((current_index = source.indexOf(text, current_index + 1)) != -1)
 count++;
 return count;
 }

 public static int countText(TextSearcher searcher, String text)
 {
 final List<Integer> foundIndices = new ArrayList<>();

 TextSearcher.TextHandler handler = (source, text1) -> {
 int current_index = 0;
 while ((source.indexOf(text1, current_index + 1)) != -1)
 {
 current_index = source.indexOf(text1, current_index +1);
 foundIndices.add(current_index);
 }
 return true;
 };

 searcher.searchForTexts(handler, Arrays.asList(text));
 return foundIndices.size();
 }

 public static void assertTextNotPresent(TextSearcher searcher, String... texts)
 {
 // Number of characters on either side of found text to include in error message
 final int RANGE = 20;
 List<String> errors = new ArrayList<>();

 TextSearcher.TextHandler handler = (htmlSource, text) -> {
 int position = htmlSource.indexOf(text);

 if (position > -1)
 {
 int prefixStart = Math.max(0, position - RANGE);
 int suffixEnd = Math.min(htmlSource.length() - 1, position + text.length() + RANGE);
 String prefix = htmlSource.substring(prefixStart, position);
 String suffix = htmlSource.substring(position + text.length(), suffixEnd);

 errors.add("Text '" + text + "' was present: " + prefix + "[" + text + "]" + suffix);
 }

 return true;
 };

 searcher.searchForTexts(handler, Arrays.asList(texts));
 Assert.assertTrue(String.join("\n", errors), errors.isEmpty());
 }

 public void assertTextNotPresent(String... texts)
 {
 TextSearcher searcher = new TextSearcher(this);
 searcher.setSearchTransformer(TextTransformers.ENCODE_HTML.andThen(t -> t.replace("&nbsp;", " ")));

 assertTextNotPresent(searcher, texts);
 }

 public String getTextInTable(String dataRegion, int row, int column)
 {
 String id = Locator.xq(dataRegion);
 return getDriver().findElement(By.xpath("//table[@id=" + id + "]/tbody/tr[" + row + "]/td[" + column + "]")).getText();
 }

 public void assertTextAtPlaceInTable(String textToCheck, String dataRegion, int row, int column)
 {
 assertEquals(textToCheck + " is not at that place in the table", textToCheck, getTextInTable(dataRegion, row, column));
 }

 public String getTextInNonDataRegionTable(String title, int row, int column)
 {
 Locator.XPathLocator tableLoc = Locator.tagWithAttribute("div", "name", "webpart")
 .withDescendant(Locator.tagWithClass("span", "labkey-wp-title-text").withText(title))
 .descendant(Locator.tagWithClass("table", "labkey-data-region-legacy"));
 return getTableCellText(tableLoc, row, column);
 }

 public void assertTableRowInNonDataRegionTable(String title, String textToCheck, int row, int column)
 {
 assertEquals(textToCheck + " is not at that place in the table", textToCheck, getTextInNonDataRegionTable(title, row, column));
 }

 /**
 * Searches only the displayed text in the body of the page, not the HTML source.
 */
 public boolean isTextBefore(String text1, String text2)
 {
 String source = getBodyText();
 return (source.indexOf(text1) < source.indexOf(text2));
 }

 /**
 * @return null = yes, present in this order
 * otherwise returns out of order string and explanation of error
 */
 public String isPresentInThisOrder(String... text)
 {
 String source = getBodyText();
 int previousIndex = -1;
 String previousString = null;

 for (String s : text)
 {
 int index = source.indexOf(s);

 if(index == -1)
 return s + " not found";
 if(index <= previousIndex)
 return s + " occurred out of order; came before " + previousString;
 previousIndex = index;
 previousString = s;
 }
 return null;
 }

 // Searches only the displayed text in the body of the page, not the HTML source.
 public void assertTextPresentInThisOrder(String... texts)
 {
 TextSearcher searcher = new TextSearcher(this::getBodyText);
 assertTextPresentInThisOrder(searcher, texts);
 }

 public void assertTextPresentInThisOrder(TextSearcher searcher, String... texts)
 {
 List<String> foundTextInOrder = getTextOrder(searcher, texts);
 assertEquals("Text found out of order.", Arrays.asList(texts), foundTextInOrder);
 }

 public void assertTextBefore(String text1, String text2)
 {
 assertTextPresentInThisOrder(text1, text2);
 }

 private void waitForPageToLoad(WebElement toBeStale, Timer timer)
 {
 try
 {
 new WebDriverWait(getDriver(), timer.timeRemaining())
 .withMessage("waiting for browser to navigate")
 .until(ExpectedConditions.stalenessOf(toBeStale));
 }
 catch (TimeoutException ex)
 {
 throw new TestTimeoutException(ex); // Triggers thread dump.
 }
 catch (WebDriverException | NullPointerException ignore)
 {
 // `ExpectedConditions.stalenessOf(toBeStale)` sometimes chokes when coming from a blank page (about:blank)
 }

 // WebDriver usually does this automatically, but not always.
 new WebDriverWait(getDriver(), timer.timeRemaining())
 .withMessage("waiting for document to be ready")
 .until(wd -> Objects.equals(executeScript("return document.readyState;"), "complete"));
 Locators.documentRoot.waitForElement(getDriver(), (int) timer.timeRemaining().toMillis());
 if (TestProperties.isDumpBrowserConsole())
 {
 executeScript("""
 if (console.everything === undefined)
 {
 console.everything = [];

 console.defaultLog = console.log.bind(console);
 console.log = function(){
 console.everything.push({"type":"log", "datetime":Date().toLocaleString(), "value":Array.from(arguments)});
 console.defaultLog.apply(console, arguments);
 }
 console.defaultError = console.error.bind(console);
 console.error = function(){
 console.everything.push({"type":"error", "datetime":Date().toLocaleString(), "value":Array.from(arguments)});
 console.defaultError.apply(console, arguments);
 }
 console.defaultWarn = console.warn.bind(console);
 console.warn = function(){
 console.everything.push({"type":"warn", "datetime":Date().toLocaleString(), "value":Array.from(arguments)});
 console.defaultWarn.apply(console, arguments);
 }
 console.defaultDebug = console.debug.bind(console);
 console.debug = function(){
 console.everything.push({"type":"debug", "datetime":Date().toLocaleString(), "value":Array.from(arguments)});
 console.defaultDebug.apply(console, arguments);
 }
 }""");
 }
 waitForOnReady("jQuery");
 waitForOnReady("Ext");
 waitForOnReady("Ext4");
 if (timer.isTimedOut())
 {
 throw new TimeoutException("Timed out waiting for JavaScript libraries to init after page load.");
 }

 List<WebElement> apps = Locator.findElements(getDriver(),
 Locator.tagWithAttributeContaining("div", "id", "error-handler-app"), // from errorView.jsp
 Locator.id("app")); // Most other apps start with an empty '<div id="app"></div>'
 for (WebElement app : apps)
 {
 waitFor(() -> Locator.xpath("./*").findElements(app).stream()
 .anyMatch(webElement ->
 {
 try
 {
 return webElement.isDisplayed();
 }
 catch (StaleElementReferenceException stale)
 {
 return false;
 }
 }), "App didn't seem to load. No visible content. " + app.toString(), (int) timer.timeRemaining().toMillis());
 }
 }

 /**
 * Wait for JavaScript API's onReady
 * @param apiName Will return when {apiName}.onReady calls the callback
 */
 private void waitForOnReady(String apiName)
 {
 try
 {
 executeAsyncScript(apiName + ".onReady(callback);");
 }
 catch (ScriptTimeoutException e)
 {
 throw new ScriptTimeoutException("Timed out waiting for " + apiName + ".onReady(). Check server log for JavaScript errors.", e);
 }
 }

 private void waitForDocument()
 {
 waitFor(() -> null != executeScript("try {return document.documentElement;}" +
 "catch(e) {return null;}"), "Document did not load", getDefaultWaitForPage());
 }

 public long doAndWaitForPageToLoad(Runnable func)
 {
 return doAndWaitForPageToLoad(func, defaultWaitForPage);
 }

 public long doAndWaitForPageToLoad(Runnable runnable, final int msWait)
 {
 Supplier<Boolean> supplier = () -> { runnable.run(); return true; };
 return doAndMaybeWaitForPageToLoad(msWait, supplier);
 }

 /**
 * Perform some action then wait for the page to load if the result of the action indicates to do so.
 * @param msWait Maximum milliseconds to wait for the page to load. '0' for no wait.
 * @param action Performs some action that might trigger a page load. Should return 'true' to wait for a page load.
 * @return total duration in milliseconds
 */
 public long doAndMaybeWaitForPageToLoad(int msWait, Supplier<Boolean> action)
 {
 Timer loadTimer = new Timer(Duration.ofMillis(msWait));
 WebElement toBeStale = null;

 if (msWait > 0)
 {
 getPageLoadListeners().forEach((listener) -> {
 if (null != listener)
 {
 TestLogger.log().trace("beforePageLoad - {}", listener.getClass().getSimpleName());
 listener.beforePageLoad();
 }
 });
 getDriver().manage().timeouts().pageLoadTimeout(Duration.ofMillis(msWait));
 toBeStale = Locators.documentRoot.findElement(getDriver()); // Document should become stale
 }

 Boolean shouldWait = action.get();

 if (msWait > 0 && shouldWait)
 {
 waitForPageToLoad(toBeStale, loadTimer);
 getDriver().manage().timeouts().pageLoadTimeout(Duration.ofMillis(defaultWaitForPage));
 getPageLoadListeners().forEach((listener) -> {
 if (null != listener)
 {
 TestLogger.log().trace("afterPageLoad - {}", listener.getClass().getSimpleName());
 listener.afterPageLoad();
 }
 });
 if (onLabKeyPage() && getDriver().getTitle().isEmpty())
 {
 String warning = "Action doesn't define a page title";
 addActionWarning(warning, getDriver().getCurrentUrl());
 }
 }

 return loadTimer.elapsed().toMillis();
 }

 public void doAndWaitForNewWindow(Runnable action)
 {
 Set<String> windows = getDriver().getWindowHandles();
 action.run();
 switchToWindow(windows.size());
 waitForDocument();
 }

 public long doAndWaitForWindow(Runnable action, String windowName)
 {
 String initialWindow = getDriver().getWindowHandle();
 AtomicBoolean targetWindowExists = new AtomicBoolean(false);
 try
 {
 getDriver().switchTo().window(windowName);
 targetWindowExists.set(true);
 }
 catch (NoSuchWindowException e)
 {
 targetWindowExists.set(false);
 }

 // Call doAndMaybeWaitForPageToLoad with target window in focus (if present)
 // Then it will correctly detect the page load in that window
 return doAndMaybeWaitForPageToLoad(10_000, () -> {
 if (targetWindowExists.get())
 getDriver().switchTo().window(initialWindow);

 action.run();

 new WebDriverWait(getDriver(), Duration.ofSeconds(5)).until(windowIsPresent(windowName));

 return targetWindowExists.get();
 });
 }

 public long doAndAcceptUnloadAlert(Runnable func, String partialAlertText)
 {
 return doAndWaitForPageToLoad(() ->
 {
 func.run();
 assertAlertContains(partialAlertText);
 });
 }

 public long doAndAcceptUnloadAlert(Runnable func)
 {
 return doAndAcceptUnloadAlert(func, "");
 }

 private static final MultiValuedMap<String, String> actionWarnings = new HashSetValuedHashMap<>();

 public static void addActionWarning(String warning, String url)
 {
 Crawler.ControllerActionId action = new Crawler.ControllerActionId(url);
 if (!action.getAction().equals("app")) // App actions generally define their title dynamically
 {
 TestLogger.warn(warning + ": " + url);
 actionWarnings.put(warning, action.toString());
 }
 }

 public static Map<String, Collection<String>> getActionWarnings()
 {
 return actionWarnings.asMap();
 }

 private static final WeakHashMap<WebDriver, Set<PageLoadListener>> _pageLoadListeners = new WeakHashMap<>();

 public void addPageLoadListener(PageLoadListener listener)
 {
 getPageLoadListeners().add(listener);
 }

 protected void clearPageLoadListeners()
 {
 getPageLoadListeners().clear();
 }

 private Set<PageLoadListener> getPageLoadListeners()
 {
 return _pageLoadListeners.computeIfAbsent(getDriver(), k -> Collections.newSetFromMap(new WeakHashMap<>()));
 }

 /**
 * Interface for classes that want to be notified of page loads (e.g. to clear a cache)
 * Not guarianteed to work flawlessly. It depends on tests using {@linkplain #doAndWaitForPageToLoad(Runnable)}
 */
 public interface PageLoadListener
 {
 default void beforePageLoad(){}
 default void afterPageLoad(){}
 }

 /**
 * Wait for signaling element created by LABKEY.Utils.signalWebDriverTest
 * If signal element is already present, this will wait for it to become stale and be recreated
 * @param func Function that will trigger the desired signal to appear on the page
 * @param signalName Should match the signal name defined in LABKEY.Utils.signalWebDriverTest
 * @return The 'value' of the signal, if any
 */
 public String doAndWaitForPageSignal(Runnable func, String signalName)
 {
 return doAndWaitForPageSignal(func, signalName, shortWait());
 }

 /**
 * Wait for signaling element created by LABKEY.Utils.signalWebDriverTest
 * If signal element is already present, this will wait for it to become stale and be recreated
 * @param func Function that will trigger the desired signal to appear on the page
 * @param signalName Should match the signal name defined in LABKEY.Utils.signalWebDriverTest
 * @return The 'value' of the signal, if any
 */
 public String doAndWaitForPageSignal(Runnable func, String signalName, WebDriverWait wait)
 {
 return doAndWaitForRepeatedPageSignal(func, signalName, Duration.ZERO, wait);
 }

 public String doAndWaitForRepeatedPageSignal(Runnable func, String signalName)
 {
 return doAndWaitForRepeatedPageSignal(func, signalName, Duration.ofSeconds(2));
 }

 public String doAndWaitForRepeatedPageSignal(Runnable func, String signalName, Duration quietPeriod)
 {
 return doAndWaitForRepeatedPageSignal(func, signalName, quietPeriod, shortWait());
 }

 /**
 * Wait for signaling element created by LABKEY.Utils.signalWebDriverTest
 * For signals that may be fired in rapid succession
 * @param func Function that will trigger the desired signal to appear on the page
 * @param signalName Should match the signal name defined in LABKEY.Utils.signalWebDriverTest
 * @param quietPeriod Wait this long for signal to stop firing
 * @return The 'value' of the signal
 */
 public String doAndWaitForRepeatedPageSignal(Runnable func, String signalName, Duration quietPeriod, WebDriverWait wait)
 {
 String signalId = null;
 WebElement signalEl = doAndWaitForElementToRefresh(func, Locators.pageSignal(signalName), wait);
 Timer timer = new Timer(Duration.ofMillis(WAIT_FOR_JAVASCRIPT));
 String value = null;
 while (!timer.isTimedOut())
 {
 try
 {
 String nextSignalId = signalEl.getAttribute("id");
 value = signalEl.getAttribute("value");

 if (quietPeriod.isZero() || nextSignalId.equals(signalId))
 {
 timer.cancel();
 }
 else
 {
 signalId = nextSignalId;
 sleep(quietPeriod.toMillis());
 }
 }
 catch (StaleElementReferenceException ignore) { }
 finally
 {
 signalEl = Locators.pageSignal(signalName).findElement(getDriver());
 }
 }
 return value;
 }

 /**
 * Do something that should make an element disappear and reappear
 */
 public WebElement doAndWaitForElementToRefresh(Runnable func, Supplier<WebElement> elementFinder, WebDriverWait wait)
 {
 WebElement previousElement = null;
 try
 {
 previousElement = elementFinder.get();
 }
 catch (NoSuchElementException ignore) {}

 func.run();

 if (previousElement != null)
 {
 wait.until(LabKeyExpectedConditions.stalenessOf(previousElement));
 }

 return wait.until(wd -> elementFinder.get());
 }

 public WebElement doAndWaitForElementToRefresh(Runnable func, Locator loc, SearchContext context, WebDriverWait wait)
 {
 return doAndWaitForElementToRefresh(func, () -> loc.findElement(context), (WebDriverWait) wait.withMessage("element to refresh: " + loc.toString()));
 }

 public WebElement doAndWaitForElementToRefresh(Runnable func, Locator loc, WebDriverWait wait)
 {
 return doAndWaitForElementToRefresh(func, loc, getDriver(), wait);
 }

 /**
 * Wait for Supplier to return non-null non-false value
 * @param wait milliseconds
 * @return final result of Supplier.get()
 * @see Timer#waitFor(Supplier)
 */
 @Contract(pure = true)
 public static <T> T waitFor(Supplier<T> checker, int wait)
 {
 return new Timer(Duration.ofMillis(wait)).waitFor(checker);
 }

 public static void waitForEquals(String message, Supplier<?> expected, Supplier<?> actual, int wait)
 {
 if (!waitFor(() -> Objects.equals(expected.get(), actual.get()), wait))
 {
 assertEquals(message, expected.get(), actual.get());
 }
 }

 public static void waitForNotEquals(String message, Supplier<?> expected, Supplier<?> actual, int wait)
 {
 if (!waitFor(() -> !Objects.equals(expected.get(), actual.get()), wait))
 {
 assertNotEquals(message, expected.get(), actual.get());
 }
 }

 /**
 * @see Timer#waitFor(Supplier, String)
 */
 public static <T> T waitFor(Supplier<T> checker, String failMessage, int wait)
 {
 return new Timer(Duration.ofMillis(wait)).waitFor(checker, failMessage);
 }

 /**
 * @see Timer#waitFor(Supplier, Supplier)
 */
 public static <T> T waitFor(Supplier<T> checker, Supplier<String> failMessageSupplier, int wait)
 {
 return new Timer(Duration.ofMillis(wait)).waitFor(checker, failMessageSupplier);
 }

 public File clickAndWaitForDownload(Locator elementToClick)
 {
 return clickAndWaitForDownload(elementToClick.findElement(getDriver()));
 }

 public File[] clickAndWaitForDownload(final Locator elementToClick, final int expectedFileCount)
 {
 return clickAndWaitForDownload(elementToClick.findElement(getDriver()), expectedFileCount);
 }

 public File clickAndWaitForDownload(final WebElement elementToClick)
 {
 return clickAndWaitForDownload(elementToClick, 1)[0];
 }

 public File[] clickAndWaitForDownload(final WebElement elementToClick, final int expectedFileCount)
 {
 return doAndWaitForDownload(elementToClick::click, expectedFileCount);
 }

 public File doAndWaitForDownload(Runnable func)
 {
 return doAndWaitForDownload(func, 1)[0];
 }

 public File downloadFromUrl(String url)
 {
 return doAndWaitForDownload(() -> {
 executeScript("document.location = arguments[0]", url);
 });
 }

 // Pattern matcher for UUID
 // https://stackoverflow.com/questions/136505/searching-for-uuids-in-text-with-regex
 private static final Pattern TEMP_FILE_PATTERN = Pattern.compile("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\\.tmp");

 public File[] doAndWaitForDownload(Runnable func, final int expectedFileCount)
 {
 final File downloadDir = BaseWebDriverTest.getDownloadDir();
 File[] existingFiles = downloadDir.listFiles();

 func.run();

 File[] newFiles = getNewFiles(expectedFileCount, downloadDir, existingFiles);

 log("File(s) downloaded to " + downloadDir);
 for (File newFile : newFiles)
 {
 log(" File downloaded: " + newFile.getName());
 }
 assertEquals("Wrong number of files downloaded to " + downloadDir, expectedFileCount, newFiles.length);

 return newFiles;
 }

 public static File[] getNewFiles(int minFileCount, File downloadDir, @Nullable File[] ignoredFiles)
 {
 final FileFilter tempFilesFilter = file -> file.getName().contains(".part") ||
 file.getName().contains(".com.google.Chrome") ||
 file.getName().contains(".crdownload") || TEMP_FILE_PATTERN.matcher(file.getName()).matches();

 final List<File> ignoredFilesList = ignoredFiles == null ? List.of() : Arrays.asList(ignoredFiles);
 final FileFilter newFileFilter = file -> !ignoredFilesList.contains(file);

 waitFor(() ->{
 final File[] files = downloadDir.listFiles(newFileFilter);
 return files != null && files.length >= minFileCount;
 },
 "File(s) did not appear in download dir: " + downloadDir.toString(), WAIT_FOR_PAGE);

 List<File> tempFiles = new ArrayList<>();
 waitFor(() -> {
 final File[] files = downloadDir.listFiles(tempFilesFilter);
 tempFiles.clear();
 if (files != null)
 {
 tempFiles.addAll(Arrays.asList(files));
 }
 return files != null && files.length == 0;
 },
 () -> "Temp files remain in download dir: " + downloadDir + ": " + tempFiles.stream().map(File::getName).collect(Collectors.joining(", ")), WAIT_FOR_PAGE);

 MutableInt downloadSize = new MutableInt(-1);
 MutableInt stabilityDuration = new MutableInt(0);
 waitFor(() -> {
 int previousSize = downloadSize.getValue();
 downloadSize.setValue(0);
 final File[] files = downloadDir.listFiles(newFileFilter);

 for (File file : files)
 downloadSize.add(file.length());

 if (downloadSize.getValue() == previousSize && downloadDir.listFiles(tempFilesFilter).length == 0)
 stabilityDuration.increment();
 else
 stabilityDuration.setValue(0);

 return stabilityDuration.getValue() > 5;
 },
 "File(s) didn't finish downloading to " + downloadDir, WAIT_FOR_PAGE);

 return downloadDir.listFiles(newFileFilter);
 }

 public WebElement waitForElement(final Locator locator)
 {
 return waitForElement(locator, WAIT_FOR_JAVASCRIPT);
 }

 public WebElement waitForElement(final Locator locator, int wait)
 {
 return locator.waitForElement(getDriver(), wait);
 }

 /**
 *
 * @param locator Element to wait for
 * @param elementTimeout amount of time to wait for
 * @param failIfNotFound should fail if element is not found? If not, will return false
 * @return did element appear?
 */
 public boolean waitForElement(final Locator locator, int elementTimeout, boolean failIfNotFound)
 {
 if (failIfNotFound)
 {
 locator.waitForElement(getDriver(), elementTimeout);
 }
 else
 {
 try
 {
 locator.waitForElement(getDriver(), elementTimeout);
 }
 catch(NoSuchElementException e)
 {
 return false;
 }
 }
 return true;
 }

 public WebElement waitForElementToBeVisible(final Locator locator)
 {
 // waitForElement first, to differentiate between element never present vs not visible
 WebElement element = waitForElement(locator);
 waitFor(element::isDisplayed,
 "Timeout waiting for element to become visible", BaseWebDriverTest.WAIT_FOR_JAVASCRIPT);
 return element;
 }

 public WebElement waitForAnyElement(String error, final Locator... locators)
 {
 if (locators.length == 0)
 throw new IllegalArgumentException("Specify at least one Locator");

 try
 {
 return shortWait().until(webDriver -> {
 for (Locator loc : locators)
 {
 try
 {
 return loc.findElement(webDriver);
 }
 catch (NoSuchElementException ignore) {}
 }
 return null;
 });
 }
 catch (TimeoutException notFound)
 {
 throw new NoSuchElementException(error);
 }
 }

 public WebElement waitForAnyElement(final Locator... locators)
 {
 return waitForAnyElement("None of the specified elements appeared", locators);
 }

 public List<WebElement> waitForElements(final Locator... locators)
 {
 if (locators.length > 0)
 {
 return shortWait().withMessage("elements to appear").until(context -> {
 List<WebElement> allElements = new ArrayList<>();
 for (Locator loc : locators)
 {
 List<WebElement> elements = loc.findElements(context);
 if (elements.isEmpty())
 return null;
 allElements.addAll(elements);
 }
 return allElements;
 });
 }
 return null;
 }

 public WebElement waitForElementWithRefresh(Locator loc, int wait)
 {
 long startTime = System.currentTimeMillis();

 do
 {
 try
 {
 return waitForElement(loc, 1000);
 }
 catch (NoSuchElementException retry)
 {
 refresh();
 }
 }while(System.currentTimeMillis() - startTime < wait);

 return waitForElement(loc, 1000);
 }

 public void waitForElementText(final Locator locator, final String text)
 {
 waitForElementText(locator, text, WAIT_FOR_JAVASCRIPT);
 }

 public void waitForElementText(final Locator locator, final String text, int wait)
 {
 waitFor(() -> getText(locator).equals(text),
 "Expected '" + text + "' in element '" + locator + "'", wait);
 }

 public void waitForElementToDisappear(final Locator locator)
 {
 waitForElementToDisappear(locator, WAIT_FOR_JAVASCRIPT);
 }

 public void waitForElementToDisappear(final Locator locator, int wait)
 {
 locator.waitForElementToDisappear(getDriver(), wait);
 }

 public void waitForElementToDisappearWithRefresh(Locator loc, int wait)
 {
 long startTime = System.currentTimeMillis();

 do
 {
 if(!isElementPresent(loc))
 return;
 refresh();
 }while(System.currentTimeMillis() - startTime < wait);

 waitForElementToDisappear(loc, 1000);
 }

 public void waitForTextToDisappear(final String text)
 {
 waitForTextToDisappear(text, WAIT_FOR_JAVASCRIPT);
 }

 public void waitForTextToDisappear(final String text, int wait)
 {
 String failMessage = "Text: " + text + " was still present after [" + wait + " ms]";
 waitFor(() -> !isTextPresent(text), failMessage, wait);
 }

 public void waitForTextWithRefresh(int wait, String... text)
 {
 long startTime = System.currentTimeMillis();

 do
 {
 if (waitFor(() -> isTextPresent(text), 1000))
 {
 return;
 }
 refresh();
 }while(System.currentTimeMillis() - startTime < wait);
 assertTextPresent(text);
 }

 public void waitForText(final String... text)
 {
 waitForText(WAIT_FOR_JAVASCRIPT, text);
 }

 public void waitForText(int wait, final String... text)
 {
 waitFor(() -> isTextPresent(text), wait);
 assertTextPresent(text);
 }

 public void waitForText(final String text, final int count, int wait)
 {
 final String failMessage = "'" + text + "' was not present " + count + " times.";
 waitFor(() -> countText(text) == count, failMessage, wait);
 }

 public boolean isElementPresent(Locator loc)
 {
 return !loc.findElements(getDriver()).isEmpty();
 }

 public boolean isElementVisible(Locator loc)
 {
 return loc.findElement(getDriver()).isDisplayed();
 }

 public WebElement assertElementPresent(Locator loc)
 {
 Optional<WebElement> optionalElement = loc.findOptionalElement(getDriver());
 assertTrue("Element is not present: " + loc.getLoggableDescription(), optionalElement.isPresent());
 return optionalElement.get();
 }

 public List<WebElement> assertElementPresent(Locator loc, int amount)
 {
 return assertElementPresent("Element '" + loc + "' is not present " + amount + " times", loc, amount);
 }

 public List<WebElement> assertElementPresent(String message, Locator loc, int amount)
 {
 List<WebElement> elements = loc.findElements(getDriver());
 assertEquals(message, amount, elements.size());
 return elements;
 }

 public void assertElementContains(Locator loc, String text)
 {
 String elemText = loc.findElement(getDriver()).getText();
 if(elemText == null)
 fail("The element at location " + loc + " contains no text! Expected '" + text + "'.");
 if(!elemText.contains(text))
 fail("The element at location '" + loc + "' contains '" + elemText + "'; expected '" + text + "'.");
 }

 public boolean elementContains(Locator loc, String text)
 {
 String elemText = loc.findElement(getDriver()).getText();
 return (elemText != null && elemText.contains(text));
 }

 public void waitForFormElementToEqual(final WebElement el, final String value)
 {
 String failMessage = "Field with name " + el.getAttribute("name") + " did not have expected value";
 waitForEquals(failMessage, () -> value, () -> getFormElement(el), WAIT_FOR_JAVASCRIPT);
 }

 public void waitForFormElementToEqual(final Locator locator, final String value)
 {
 waitForFormElementToEqual(new EphemeralWebElement(locator, getDriver()), value);
 }

 public void waitForFormElementToNotEqual(final WebElement el, final String value)
 {
 String failMessage = "Field with name " + el.getAttribute("name") + " did change value";
 waitForNotEquals(failMessage, () -> value, () -> getFormElement(el), WAIT_FOR_JAVASCRIPT);
 }

 public void waitForFormElementToNotEqual(final Locator locator, final String value)
 {
 waitForFormElementToNotEqual(new EphemeralWebElement(locator, getDriver()), value);
 }

 public String getFormElement(Locator loc)
 {
 return getFormElement(loc.findElement(getDriver()));
 }

 public String getFormElement(WebElement el)
 {
 return el.getDomProperty("value");
 }

 /**
 * @deprecated Use {@link org.junit.Assert#assertEquals(String, Object, Object)} and
 * {@link #getSelectedOptionText(Locator)}
 */
 @Deprecated
 public void assertOptionEquals(Locator loc, String value)
 {
 assertEquals(value, getSelectedOptionText(loc));
 }

 public String getSelectedOptionText(Locator loc)
 {
 return getSelectedOptionText(loc.findElement(getDriver()));
 }

 public String getSelectedOptionText(WebElement el)
 {
 Select select = new Select(el);
 return select.getFirstSelectedOption().getText();
 }

 public List<String> getSelectedOptionTexts(Locator loc)
 {
 Select select = new Select(loc.findElement(getDriver()));
 return select.getAllSelectedOptions().stream().map(WebElement::getText).collect(Collectors.toList());
 }

 public String getSelectedOptionValue(Locator loc)
 {
 return getSelectedOptionValue(loc.findElement(getDriver()));
 }

 public String getSelectedOptionValue(WebElement el)
 {
 Select select = new Select(el);
 return select.getFirstSelectedOption().getAttribute("value");
 }

 public List<String> getSelectedOptionValues(Locator loc)
 {
 Select select = new Select(loc.findElement(getDriver()));
 List<WebElement> selectedOptions = select.getAllSelectedOptions();
 List<String> values = new ArrayList<>();
 for (WebElement selectedOption : selectedOptions)
 values.add(selectedOption.getAttribute("value"));
 return values;
 }

 public List<String> getSelectOptions(Locator loc)
 {
 Select select = new Select(loc.findElement(getDriver()));
 List<WebElement> selectOptions = select.getOptions();
 return getTexts(selectOptions);
 }

 public void assertElementNotPresent(String errorMsg, Locator loc)
 {
 assertFalse(errorMsg, isElementPresent(loc));
 }

 public void assertElementNotPresent(Locator loc)
 {
 assertElementNotPresent("Element was present in page: " + loc, loc);
 }

 public void assertElementNotVisible(Locator loc)
 {
 assertFalse("Element was visible in page: " + loc, loc.findElement(getDriver()).isDisplayed());
 }

 public void assertElementVisible(Locator loc)
 {
 assertTrue("Element was not visible: " + loc, loc.findElement(getDriver()).isDisplayed());
 }

 public WebElement scrollIntoView(Locator loc)
 {
 return scrollIntoView(loc.findElement(getDriver()));
 }

 public WebElement scrollIntoView(Locator loc, Boolean alignToTop)
 {
 return scrollIntoView(loc.findElement(getDriver()), alignToTop);
 }

 public WebElement scrollIntoView(WebElement el)
 {
 return scrollIntoView(el, false);
 }

 public WebElement scrollIntoView(WebElement el, Boolean alignToTop)
 {
 return ScrollUtils.scrollIntoView(el, alignToTop);
 }

 public WebElement scrollToMiddle(WebElement element)
 {
 return ScrollUtils.scrollToMiddle(element);
 }

 public void scrollToTop()
 {
 ScrollUtils.scrollTo(getDriver(), 0, 0);
 }

 public void scrollBy(Integer x, Integer y)
 {
 ScrollUtils.scrollBy(getDriver(), x, y);
 }

 /**
 * @deprecated Use {@link WebElement#click()}
 * find and waitFor methods in Locator now return decorated WebElements that provide special click handling
 */
 @Deprecated
 public void click(WebElement el)
 {
 el.click();
 }

 public void click(Locator l)
 {
 clickAndWait(l, 0);
 }

 public void clickAt(Locator l, int xCoord, int yCoord)
 {
 clickAt(l, xCoord, yCoord, WAIT_FOR_PAGE);
 }

 public void clickAt(Locator l, int xCoord, int yCoord, int pageTimeout)
 {
 WebElement el = l.waitForElement(getDriver(), WAIT_FOR_JAVASCRIPT);
 clickAt(el, xCoord, yCoord, pageTimeout);
 }

 public void clickAt(final WebElement el, final int xCoord, final int yCoord, int pageTimeout)
 {
 doAndWaitForPageToLoad(() ->
 {
 Actions builder = new Actions(getDriver());
 builder.moveToElement(el, xCoord, yCoord)
 .click()
 .build()
 .perform();
 }, pageTimeout);
 }

 public void clickAndWait(Locator l)
 {
 clickAndWait(l, defaultWaitForPage);
 }

 public void openLinkInNewWindow(WebElement link)
 {
 link.sendKeys(Keys.chord(WebDriverUtils.MODIFIER_KEY, Keys.ENTER));
 switchToWindow(1);
 waitForDocument();
 }

 public static final int WAIT_FOR_EXT_MASK_TO_DISSAPEAR = -1;
 public static final int WAIT_FOR_EXT_MASK_TO_APPEAR = -2;

 public void clickAndWait(Locator l, int pageTimeoutMs)
 {
 WebElement el;
 try
 {
 el = l.findElement(getDriver());
 clickAndWait(el, pageTimeoutMs);
 }
 catch (StaleElementReferenceException e)
 {
 // Locator.findElement likely didn't return the element we wanted due to timing problem. Wait and try again.
 // Ideally we'd decorate WebElement to know its locator and encapsulate the retry.
 sleep(500);
 el = l.findElement(getDriver());
 clickAndWait(el, pageTimeoutMs);
 log("WARNING: Need to improve timing, clicked element immediately became stale.: " + el.toString());
 }
 }

 public void clickAndWait(WebElement el)
 {
 clickAndWait(el, getDefaultWaitForPage());
 }

 public void clickAndWait(final WebElement el, int pageTimeoutMs)
 {
 doAndWaitForPageToLoad(() ->
 {
 el.click();
 }, pageTimeoutMs);

 if(pageTimeoutMs==WAIT_FOR_EXT_MASK_TO_APPEAR)
 _extHelper.waitForExt3Mask(WAIT_FOR_JAVASCRIPT);
 else if(pageTimeoutMs==WAIT_FOR_EXT_MASK_TO_DISSAPEAR)
 _extHelper.waitForExt3MaskToDisappear(WAIT_FOR_JAVASCRIPT);
 }

 public void doubleClick(Locator l)
 {
 doubleClickAndWait(l, 0);
 }

 public void doubleClickAndWait(final Locator l, int millis)
 {
 doubleClickAndWait(l.findElement(getDriver()), millis);
 }

 public void doubleClick(WebElement l)
 {
 doubleClickAndWait(l, 0);
 }

 public void doubleClickAndWait(final WebElement l, int millis)
 {
 doAndWaitForPageToLoad(() ->
 {
 Actions action = new Actions(getDriver());
 action.doubleClick(l).perform();
 }, millis);
 }

 public void selectFolderTreeItem(String folderName)
 {
 click(Locator.permissionsTreeNode(folderName));
 }

 /**
 * Move mouse to the upper left corner of the document to dismiss tooltips and the like
 */
 public void mouseOut()
 {
 try
 {
 new Actions(getDriver())
 .moveToLocation(0, 0)
 // Add a little wiggle to make sure tooltips notice
 .moveByOffset(4, 4)
 .moveByOffset(-2, -2)
 .perform();
 }
 catch (WebDriverException ignore) { }
 }

 public WebElement mouseOver(Locator l)
 {
 WebElement el = l.findElement(getDriver());
 mouseOver(el);
 return el;
 }

 public void mouseOver(WebElement el)
 {
 scrollIntoView(el);
 mouseOverWithoutScrolling(el);
 }

 public void mouseOverWithoutScrolling(WebElement el)
 {
 Actions builder = new Actions(getDriver());
 builder.moveToElement(el)
 // Add a little wiggle to make sure tooltips notice
 .moveByOffset(2, 0)
 .moveByOffset(-4, 0)
 .moveByOffset(2, 0)
 .perform();
 }

 public int getElementIndex(Locator.XPathLocator l)
 {
 return l.child("preceding-sibling::*").findElements(getDriver()).size();
 }

 public int getElementIndex(WebElement el)
 {
 return Locator.xpath("preceding-sibling::*").findElements(el).size();
 }

 public void dragAndDrop(Locator from, Locator to)
 {
 dragAndDrop(from, to, Position.top);
 }
 public void dragAndDrop(WebElement from, WebElement to)
 {
 dragAndDrop(from, to, Position.top);
 }

 public enum Position
 {top, bottom, middle}

 public void dragAndDrop(Locator from, Locator to, Position pos)
 {
 WebElement fromEl = from.findElement(getDriver());
 WebElement toEl = to.findElement(getDriver());
 dragAndDrop(fromEl, toEl, pos);
 }

 public void dragAndDrop(WebElement fromEl, WebElement toEl, Position pos)
 {
 int y = switch (pos)
 {
 case top -> 1;
 case bottom -> toEl.getSize().getHeight() - 1;
 case middle -> toEl.getSize().getHeight() / 2;
 default -> throw new IllegalArgumentException("Unexpected position: " + pos);
 };

 Actions builder = new Actions(getDriver());
 builder.clickAndHold(fromEl).moveToElement(toEl, toEl.getSize().getWidth() / 2, y).release().build().perform();
 }

 public void dragAndDrop(Locator el, int xOffset, int yOffset)
 {
 WebElement fromEl = el.findElement(getDriver());
 dragAndDrop(fromEl, xOffset, yOffset);
 }

 public void dragAndDrop(WebElement fromEl, int xOffset, int yOffset)
 {
 Actions builder = new Actions(getDriver());
 builder.clickAndHold(fromEl).moveByOffset(xOffset + 1, yOffset + 1).release().build().perform();
 }

 // This is useful when making a draggin selection in a plot, and there may be many elements ontop of the one you want.
 public void dragAndDrop(int xOffset, int yOffset)
 {
 Actions builder = new Actions(getDriver());
 builder.clickAndHold().moveByOffset(xOffset + 1, yOffset + 1).release().build().perform();
 }

 /**
 * @deprecated Use {@link #getTableCellText(org.labkey.test.Locator.XPathLocator, int, int)}
 */
 @Deprecated
 private String getTableCellText(String tableId, int row, int column)
 {
 return getTableCellText(Locator.xpath("//table[@id=" + Locator.xq(tableId) + "]"), row, column);
 }

 public String getTableCellText(Locator.XPathLocator table, int row, int column)
 {
 return getText(getSimpleTableCell(table, row, column));
 }

 public Locator getSimpleTableCell(Locator.XPathLocator table, int row, int column)
 {
 return table.append("/tbody/tr[" + (row + 1) + "]/*[self::td or self::th][" + (column + 1) + "]");
 }

 /**
 * @deprecated Use {@link #getTableCellText(org.labkey.test.Locator.XPathLocator, int, int)} and {@link org.junit.Assert#assertEquals(Object, Object)}
 */
 @Deprecated public void assertTableCellTextEquals(String tableName, int row, int column, String value)
 {
 assertEquals(tableName + "." + row + "." + column + " != \"" + value + "\"", value, getTableCellText(tableName, row, column));
 }

 /**
 * @deprecated Use {@link #getTableCellText(org.labkey.test.Locator.XPathLocator, int, int)} and {@link #assertElementContains(Locator, String)}
 */
 @Deprecated public void assertTableCellContains(String tableName, int row, int column, String... strs)
 {
 String cellText = getTableCellText(tableName, row, column);

 for (String str : strs)
 {
 assertTrue(tableName + "." + row + "." + column + " should contain '" + str + "' (actual value is " + cellText + ")", cellText.contains(str));
 }
 }

 /**
 * @deprecated Use {@link #getTableCellText(org.labkey.test.Locator.XPathLocator, int, int)}
 */
 @Deprecated public void assertTableCellNotContains(String tableName, int row, int column, String... strs)
 {
 String cellText = getTableCellText(tableName, row, column);

 for (String str : strs)
 {
 assertFalse(tableName + "." + row + "." + column + " should not contain '" + str + "'", cellText.contains(str));
 }
 }

 // Specifies cell values in a TSV string -- values are separated by tabs, rows are separated by \n
 public void assertTableRowsEqual(String tableId, int startRow, String cellValuesTsv)
 {
 String[] lines = cellValuesTsv.split("\n");
 String[][] cellValues = new String[lines.length][];

 for (int row = 0; row < cellValues.length; row++)
 cellValues[row] = lines[row].split("\t");

 assertTableRowsEqual(tableId, startRow, cellValues);
 }

 public void assertTableRowsEqual(String tableId, int startRow, String[][] cellValues)
 {
 for (int row = 0; row < cellValues.length; row++)
 for (int col = 0; col < cellValues[row].length; col++)
 assertTableCellTextEquals(tableId, row + startRow, col, cellValues[row][col]);
 }

 /**
 * @deprecated Use {@link org.labkey.test.util.DataRegionTable#getColumnDataAsText(int)}
 */
 @Deprecated
 // Returns the value of all cells in the specified column
 public List<String> getTableColumnValues(String tableName, int column)
 {
 int rowCount = getTableRowCount(tableName);

 List<String> values = new ArrayList<>(rowCount);

 for (int i = 0; i < rowCount; i++)
 {
 try
 {
 values.add(getTableCellText(Locator.id(tableName), i, column));
 }
 catch(NoSuchElementException ignore) {}
 }

 return values;
 }

 // Returns the number of rows (both <tr> and <th>) in the specified table
 public int getTableRowCount(String tableName)
 {
 return Locator.xpath("//table[@id=" + Locator.xq(tableName) + "]/thead/tr").findElements(getDriver()).size() +
 Locator.xpath("//table[@id=" + Locator.xq(tableName) + "]/tbody/tr").findElements(getDriver()).size();
 }

 /**
 * @deprecated Slow to return false. Use a specific Locator
 */
 @Deprecated
 public boolean isButtonPresent(String text)
 {
 try
 {
 findButton(text);
 return true;
 }
 catch (NoSuchElementException notPresent)
 {
 return false;
 }
 }

 public void clickButtonByIndex(String text, int index)
 {
 clickButtonByIndex(text, index, defaultWaitForPage);
 }

 public void clickButtonByIndex(String text, int index, int wait)
 {
 clickAndWait(findButton(text, index), wait);
 }

 public WebElement findButton(String text, int index)
 {
 Locator.XPathLocator locators = Locator.XPathLocator.union(
 // check for normal labkey button:
 Locator.lkButton(text).index(index),
 // check for Ext 4 button:
 Ext4Helper.Locators.ext4Button(text).index(index),
 // check for Ext button:
 Locator.extButton(text).index(index),
 // check for normal html button:
 Locator.button(text).index(index),
 // check for bootstrap button
 BootstrapLocators.button(text).index(index)
 );

 try
 {
 return waitForElement(locators);
 }
 catch (NoSuchElementException notFound)
 {
 throw new NoSuchElementException("No button found with text \"" + text + "\" at index " + index, notFound);
 }
 }

 public WebElement findButton(String text)
 {
 Locator.XPathLocator locators = Locator.XPathLocator.union(
 // normal labkey nav button:
 Locator.lkButton(text),
 // Ext 4 button:
 Ext4Helper.Locators.ext4Button(text),
 // Ext 3 button:
 Locator.extButton(text),
 // normal HTML button:
 Locator.button(text),
 // bootstrap button
 BootstrapLocators.button(text)
 );

 try
 {
 return waitForElement(locators);
 }
 catch (NoSuchElementException tryCaps)
 {
 if (!text.equals(text.toUpperCase()))
 {
 log("WARNING: Update test. Possible wrong casing for button: " + text);
 try
 {
 return findButton(text.toUpperCase());
 }
 catch (NoSuchElementException capsFailed) {}
 }
 throw new NoSuchElementException("No button found with text " + text, tryCaps);
 }
 }

 protected WebElement findButtonContainingText(String text)
 {
 Locator.XPathLocator locators = Locator.XPathLocator.union(
 // normal labkey button:
 Locator.lkButton().containing(text),
 // Ext 4 button:
 Ext4Helper.Locators.ext4ButtonContainingText(text),
 // Ext 3 button:
 Locator.extButtonContainingText(text),
 // normal HTML button:
 Locator.buttonContainingText(text),
 // check for bootstrap button
 BootstrapLocators.button().containing(text)
 );

 try
 {
 return waitForElement(locators);
 }
 catch (NoSuchElementException notFound)
 {
 throw new NoSuchElementException("No button found containing text " + text, notFound);
 }
 }

 /**
 * Wait for a button to appear, click it, then waits for the page to load.
 * Use clickButton(text, 0) to click a button and continue immediately.
 */
 public void clickButton(String text)
 {
 clickButton(text, defaultWaitForPage);
 }

 /**
 * Wait for a button to appear, click it, then waits for the text to appear.
 * @deprecated This method provides minimal convenience and behaves inconsistently with other 'clickButton' methods
 */
 @Deprecated(since = "21.8")
 public void clickButton(String text, String waitForText)
 {
 if (isTextPresent(waitForText))
 {
 throw new IllegalStateException("'" + waitForText + "' is already present on the page. Pick a better indicator that the page state has changed.");
 }
 clickButton(text, 0);
 waitForText(waitForText);
 }

 /**
 * Wait for a button to appear, click it, then wait for <code>waitMillis</code> for the page to load.
 */
 public void clickButton(final String text, int waitMillis)
 {
 clickButton(text, waitMillis, 0);
 }

 /**
 * Wait for a button to appear, click it, then wait for <code>waitMillis</code> for the page to load.
 * -- which is which button of this name (first, second, etc.)
 */
 public void clickButton(final String text, int waitMillis, int which)
 {
 clickAndWait(findButton(text, which), waitMillis);
 }

 /**
 * @deprecated Avoid me please. I am bad and hacky
 * Mash button until it goes stale and page loads
 */
 @Deprecated
 public void mashButton(final String text)
 {
 WebElement button = findButton(text);
 scrollIntoView(button);
 doAndWaitForPageToLoad(() -> shortWait().until(LabKeyExpectedConditions.clickUntilStale(button)));
 }

 public void clickButtonContainingText(String text)
 {
 clickButtonContainingText(text, defaultWaitForPage);
 }

 public void clickButtonContainingText(String text, int waitMills)
 {
 clickAndWait(findButtonContainingText(text), waitMills);
 }

 public void clickButtonContainingText(String buttonText, String textShouldAppearAfterLoading)
 {
 clickButtonContainingText(buttonText, 0);
 waitForText(defaultWaitForPage, textShouldAppearAfterLoading);
 }

 /**
 * wait for element, click it, return immediately
 */
 public void waitAndClick(Locator l)
 {
 waitAndClick(WAIT_FOR_JAVASCRIPT, l, 0);
 }

 /**
 * wait for element, click it, wait for page to load
 */
 public void waitAndClickAndWait(Locator l)
 {
 waitAndClick(WAIT_FOR_JAVASCRIPT, l, WAIT_FOR_PAGE);
 }

 /**
 * wait for element, click it, wait for page to load
 */
 public void waitAndClick(int waitFor, Locator l, int waitForPageToLoad)
 {
 WebElement el = new WebDriverWait(getDriver(), Duration.ofMillis(waitFor))
 .until(ExpectedConditions.elementToBeClickable(l));
 try
 {
 clickAndWait(el, waitForPageToLoad);
 }
 catch (StaleElementReferenceException e)
 {
 // Locator.findElement likely didn't return the element we wanted due to timing problem. Wait and try again.
 // Ideally we'd decorate WebElement to know its locator and encapsulate the retry.
 sleep(500);
 el = l.findElement(getDriver());
 clickAndWait(el, waitForPageToLoad);
 }
 }

 /** @return target of link */
 public String getLinkHref(String linkText, String controller, String folderPath)
 {
 Locator link = Locator.linkWithText(linkText);
 String localAddress = getButtonHref(link, true);
 // IE puts the entire link in href, not just the local address
 if (localAddress.contains("/"))
 {
 int location = localAddress.lastIndexOf("/");
 if (location < localAddress.length() - 1)
 localAddress = localAddress.substring(location + 1);
 }
 return (WebTestHelper.getContextPath() + "/" + controller + folderPath + "/" + localAddress);
 }


 public String getButtonHref(Locator buttonLoc, boolean truncate)
 {
 String address = getAttribute(buttonLoc, "href");
 // IE puts the entire link in href, not just the local address
 if (truncate && address.contains("/"))
 {
 int location = address.lastIndexOf("/");
 if (location < address.length() - 1)
 address = address.substring(location + 1);
 }
 return address;
 }

 public void setFormElement(Locator l, String text)
 {
 WebElement el = l.waitForElement(new WebDriverWait(getDriver(), Duration.ofMillis(WAIT_FOR_JAVASCRIPT)));
 setFormElement(el, text);
 }

 /**
 * Clears and sets the text of the specified input element.
 * Warning: Clear unfocuses the element which causes some inputs to disappear.
 * See <a href="https://www.w3.org/TR/webdriver/#element-clear">WebDriver Docs</a>
 * Use {@link WebElement#sendKeys} for such inputs.
 */
 public void setFormElement(WebElement el, String text)
 {
 String inputType = el.getDomAttribute("type");

 if ("file".equals(inputType))
 {
 TestLogger.warn("Please use a File object to set file input");
 setFormElement(el, new File(text));
 }
 else
 {
 String tagName = el.getTagName();
 if (tagName.equals("select"))
 {
 selectOption(el, text);
 }
 else if (tagName.equals("input") || tagName.equals("textarea"))
 {
 if (isHtml5InputTypeSupported(inputType))
 {
 setHtml5Input(el, inputType, text);
 }
 else
 {
 setInput(el, text);
 }
 }
 else
 {
 throw new IllegalArgumentException("Invalid element: " + el);
 }
 }
 }

 private void setInput(WebElement input, String text)
 {
 if (StringUtils.isEmpty(text))
 {
 input.clear();
 }
 else if (text.length() < 1000 && !text.contains("\n") && !text.contains("\t"))
 {
 input.clear();
 if (!waitFor(()-> getFormElement(input).isEmpty(), 500))
 {
 TestLogger.warn("Failed to clear input: " + input);
 }
 input.sendKeys(text);
 if (!waitFor(()-> getFormElement(input).equals(text), 500))
 {
 TestLogger.warn("Failed to set input: " + input);
 }
 }
 else
 {
 setFormElementJS(input, text);
 input.sendKeys(" ", Keys.BACK_SPACE); // 'change' event isn't always sufficient
 }

 try
 {
 String elementClass = input.getAttribute("class");
 if (elementClass.contains("x-form-text"))
 fireEvent(input, SeleniumEvent.blur); // Make ExtJS form elements behave better
 }
 catch(StaleElementReferenceException stale)
 {
 log("input element is stale, not going to try and fire blur event.");
 }
 }

 public void actionClick(WebElement el)
 {
 new Actions(getDriver()).moveToElement(el).click().perform();
 }

 public void actionClear(WebElement input)
 {
 Keys cmdKey = WebDriverUtils.MODIFIER_KEY;
 scrollIntoView(input);
 new Actions(getDriver())
 .keyDown(cmdKey)
 .sendKeys(input, "a") // select all
 .keyUp(cmdKey)
 .sendKeys(Keys.DELETE) // clear the input
 .perform();
 }

 /**
 * puts the specified text and html into the clipboard, then pastes it into the specified element,
 * or whatever has focus at the moment.
 */
 public void actionPaste(WebElement input, String text, boolean isHtml)
 {
 Keys cmdKey = WebDriverUtils.MODIFIER_KEY;

 setClipboardContent(text, isHtml);

 if (input == null)
 {
 new Actions(getDriver())
 .keyDown(cmdKey)
 .sendKeys("v") // paste the contents of the clipboard, without a target
 .keyUp(cmdKey)
 .perform();
 }
 else
 {
 scrollIntoView(input);
 new Actions(getDriver())
 .keyDown(cmdKey)
 .sendKeys(input, "v") // paste the contents of the clipboard into the input
 .keyUp(cmdKey)
 .perform();
 }
 }

 /**
 * puts the specified text into the clipboard, then pastes it into the specified element,
 * or whatever has focus at the moment.
 */
 public void actionPaste(WebElement input, String text)
 {
 actionPaste(input, text, false);
 }

 public void clearClipboardContent()
 {
 setClipboardContent(" ");
 }

 protected void setClipboardContent(String text, boolean isHtml)
 {
 Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard();
 Transferable sel;

 if (isHtml)
 {
 sel = new HtmlFragmentSelection(text);
 }
 else
 {
 sel = new StringSelection(text);
 }

 c.setContents(sel, null);
 }

 protected void setClipboardContent(String text)
 {
 setClipboardContent(text, false);
 }

 public String getClipboardContent() throws IOException, UnsupportedFlavorException
 {
 Transferable t = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);

 if (t != null)
 {
 DataFlavor[] flavors = t.getTransferDataFlavors();

 TestLogger.debug("Available clipboard flavors: " + Arrays.asList(flavors));
 TestLogger.debug("Best clipboard flavor: " + DataFlavor.selectBestTextFlavor(flavors));

 if (flavors.length > 0)
 {
 return (String) t.getTransferData(DataFlavor.selectBestTextFlavor(flavors));
 }
 else
 {
 // No available flavors, try pasting into a new input.
 String value = doInNewTab(() -> {
 String inputId = "testClipboardInput";
 executeScript("""
 let input = document.createElement('input');
 input.id = arguments[0];
 document.getElementsByTagName('body')[0].appendChild(input);""", inputId);

 WebElement inputElement = Locator.id(inputId).findElement(getDriver());
 new Actions(getDriver())
 .keyDown(WebDriverUtils.MODIFIER_KEY)
 .sendKeys(inputElement, "v")
 .keyUp(WebDriverUtils.MODIFIER_KEY)
 .perform();

 return inputElement.getDomProperty("value");
 });
 if (StringUtils.isEmpty(value))
 {
 throw new UnsupportedFlavorException(null);
 }
 return value;
 }
 }
 else
 {
 return null;
 }
 }

 @Nullable
 public <T> T doInNewTab(Supplier<T> supplier)
 {
 String initialWindow = getDriver().getWindowHandle();
 getDriver().switchTo().newWindow(WindowType.TAB);

 T result = supplier.get();

 getDriver().close();
 getDriver().switchTo().window(initialWindow);

 return result;
 }

 private static final List<String> html5InputTypes = Arrays.asList("color", "date", "datetime-local", "email", "month", "number", "range", "search", "tel", "time", "url", "week");
 private final Map<String, Boolean> html5InputSupport = new HashMap<>(); // Don't make static. Different tests may run on different browsers
 protected final boolean isHtml5InputTypeSupported(String inputType)
 {
 if (!html5InputTypes.contains(inputType))
 {
 return false;
 }
 if (!html5InputSupport.containsKey(inputType))
 {
 html5InputSupport.put(inputType,
 (Boolean) executeScript(
 "var i = document.createElement('input');" +
 "i.setAttribute('type', arguments[0]);" +
 "return i.type === arguments[0];"
 , inputType));
 }
 return html5InputSupport.get(inputType);
 }

 private void setHtml5Input(WebElement input, String inputType, String value)
 {
 switch (inputType)
 {
 case "date":
 setHtml5DateInput(input, value);
 break;
 case "datetime-local":
 setHtml5DateTimeInput(input, value);
 break;
 case "password":
 case "search":
 setInput(input, value); // These don't require special handling, don't output warning
 break;
 case "number":
 setHtml5NumberInput(input, value);
 break;
 default:
 TestLogger.warn(String.format("No special handling defined for HTML5 input type = '%s'.", inputType));
 setInput(input, value);
 }
 }

 private void setHtml5DateInput(WebElement el, String text)
 {
 String inputFormat = "yyyy-MM-dd";
 SimpleDateFormat inputFormatter = new SimpleDateFormat(inputFormat);

 try
 {
 setHtml5DateInput(el, inputFormatter.parse(text));
 }
 catch (ParseException e)
 {
 throw new IllegalArgumentException("Unable to parse date " + text + ". Format should be " + inputFormat);
 }
 }

 private void setHtml5DateTimeInput(WebElement el, String text)
 {
 String inputFormat = "yyyy-MM-dd'T'HH:mm";
 SimpleDateFormat inputFormatter = new SimpleDateFormat(inputFormat);

 try
 {
 setHtml5DateTimeInput(el, inputFormatter.parse(text));
 }
 catch (ParseException e)
 {
 throw new IllegalArgumentException("Unable to parse date " + text + ". Format should be " + inputFormat);
 }
 }

 private void setHtml5DateInput(WebElement el, Date date)
 {
 // Firefox requires ISO date format (yyyy-MM-dd)
 String formFormat = isFirefox() ? "yyyy-MM-dd" : "MMddyyyy";
 SimpleDateFormat formFormatter = new SimpleDateFormat(formFormat);
 String formDate = formFormatter.format(date);

 fireEvent(el, SeleniumEvent.focus);
 executeScript("arguments[0].value = ''", el);
 el.sendKeys(formDate);
 }

 private void setHtml5DateTimeInput(WebElement el, Date date)
 {
 // Firefox and Chrome want different formats, neither of which align with all online guidance to use ISO-style
 String formFormat = isFirefox() ? "MMddyyyy hh:mm a" : "MM-dd-yyyy'\t'hh:mma";
 SimpleDateFormat formFormatter = new SimpleDateFormat(formFormat);
 String formDate = formFormatter.format(date);

 fireEvent(el, SeleniumEvent.focus);
 executeScript("arguments[0].value = ''", el);
 el.sendKeys(formDate);
 }

 private void setHtml5NumberInput(WebElement el, String text)
 {

 el.clear();

 // Calling clear on the element doesn't reliably clear the field, if it fails try the hack.
 String valueAsNumber = el.getAttribute("valueAsNumber").trim().toLowerCase();
 if(!valueAsNumber.equals("nan"))
 {

 int length = valueAsNumber.length();

 el.click();

 // Not really sure where the cursor is in relation to the text so LEFT_ARROW until we are at the start.
 for(int i = 0; i < length; i++)
 {
 el.sendKeys(Keys.ARROW_LEFT);
 }

 // Now delete all of the characters.
 for(int i = 0; i < length; i++)
 {
 el.sendKeys(Keys.DELETE);
 }

 }

 // Sometimes focus is lost before the value is set, so make sure the element has focus.
 el.click();

 el.sendKeys(text);
 }

 /**
 * Set form element directly via JavaScript rather than WebElement.sendKeys
 * @param l Locator for form element
 * @param text text to set
 */
 public void setFormElementJS(Locator l, String text)
 {
 WebElement el = l.findElement(getDriver());
 setFormElementJS(el, text);
 }

 public void setFormElementJS(WebElement el, String text)
 {
 if ("select".equals(el.getTagName()))
 {
 selectOption(el, text);
 }
 else
 {
 executeScript("arguments[0].value = arguments[1]", el, text);
 }
 fireEvent(el, SeleniumEvent.change);
 }

 public void setInput(Locator loc, List<File> files)
 {
 WebElement el = loc.waitForElement(new WebDriverWait(getDriver(), Duration.ofSeconds(5)));
 setInput(el, files);
 }

 public void setInput(WebElement el, List<File> files)
 {
 for (File file : files)
 assertTrue("File not found: " + file.toString(), file.exists());

 executeScript("arguments[0].value = '';", el);
 List<String> filePaths = files.stream().map(File::getAbsolutePath).collect(Collectors.toList());
 String fileNames = String.join("\n", filePaths);
 TestLogger.debug(fileNames);
 el.sendKeys(fileNames);
 }

 public void setFormElement(Locator loc, File file)
 {
 WebElement el = loc.waitForElement(new WebDriverWait(getDriver(), Duration.ofSeconds(5)));
 setFormElement(el, file);
 }

 public void setFormElement(WebElement el, File file)
 {
 setInput(el, Collections.singletonList(file));
 }

 public void setFormElements(String tagName, String formElementName, String[] values)
 {
 for (int i = 0; i < values.length; i++)
 {
 setFormElement(Locator.tagWithName(tagName, formElementName).index(i), values[i]);
 }
 }

 /**
 * @deprecated Use {@link Locator#findElements(SearchContext)}.size()
 */
 @Deprecated
 public int getElementCount(Locator locator)
 {
 return locator.findElements(getDriver()).size();
 }

 /**
 * @deprecated Use {@link #assertElementPresent(Locator)}
 */
 @Deprecated
 public void assertButtonPresent(String buttonText)
 {
 assertTrue("Button '" + buttonText + "' was not present", isButtonPresent(buttonText));
 }

 /**
 * @deprecated Use {@link #assertElementNotPresent(Locator)}. This is slow.
 */
 @Deprecated
 public void assertButtonNotPresent(String buttonText)
 {
 assertFalse("Button '" + buttonText + "' was present", isButtonPresent(buttonText));
 }

 public RadioButton checkRadioButton(Locator radioButtonLocator)
 {
 RadioButton radioButton = RadioButton(radioButtonLocator).find(getDriver());
 radioButton.check();

 // TODO: Should review this code, and understand why it was written.
 // I'm not sure this code is doing what was intended, or is the correct thing to do.
 // I think this may be exposing a bug in the RadioButton finder. Look at baseWebDriverTest.prepareForFolderExport (line 1448).
 // The locator sent into this function is a table, which will find the input element, but it makes the base
 // element the table as well which will never returns true for checked.
 if (!waitFor(()-> radioButton.isChecked(), 250))
 radioButton.check();
 return radioButton;
 }

 public void checkCheckbox(Locator checkBoxLocator)
 {
 WebElement checkbox = checkBoxLocator.findElement(getDriver());
 checkCheckbox(checkbox);
 }

 public void checkCheckbox(WebElement el)
 {
 setCheckbox(el, true);
 }

 public void uncheckCheckbox(WebElement el)
 {
 setCheckbox(el, false);
 }

 public void setCheckbox(WebElement el, boolean check)
 {
 String type = el.getAttribute("type");
 if ("radio".equals(type))
 {
 log("WARNING: Use checkRadioButton for radio buttons");
 if (!check)
 throw new IllegalArgumentException("Unable to deselect a radio button directly");
 }
 else if (!"checkbox".equals(type))
 {
 throw new IllegalArgumentException("Element not a checkbox: " + el + "\nTry Ext4Helper or ExtHelper.");
 }

 Boolean indeterminate = executeScript("return arguments[0].indeterminate;", Boolean.class, el);
 if (indeterminate != null && indeterminate)
 {
 scrollIntoView(el);
 el.click();
 }

 boolean selected = el.isSelected();
 if (check != selected)
 {
 scrollIntoView(el);
 el.click();
 }

 try
 {

 // Have to balance between the state is now as expected and hitting a race condition between clicking
 // the element and having the isSelected attribute change.
 selected = el.isSelected();
 if (check != selected)
 {
 sleep(500);
 Assert.assertEquals("Failed to set checkbox to requested state.", check, el.isSelected());
 }

 }
 catch (StaleElementReferenceException ignore)
 {
 // In some cases the clicking the checkbox causes a refresh and the element goes stale.
 }

 }

 public void setCheckbox(Locator checkBoxLocator, boolean check)
 {
 WebElement checkbox = checkBoxLocator.findElement(getDriver());
 setCheckbox(checkbox, check);
 }

 public void assertRadioButtonSelected(Locator radioButtonLocator)
 {
 assertTrue("Radio Button is not selected at " + radioButtonLocator.toString(), isChecked(radioButtonLocator));
 }

 public void uncheckCheckbox(Locator checkBoxLocator)
 {
 WebElement checkbox = checkBoxLocator.findElement(getDriver());
 uncheckCheckbox(checkbox);
 }

 public void assertChecked(Locator checkBoxLocator)
 {
 assertTrue("Checkbox not checked at " + checkBoxLocator.toString(), isChecked(checkBoxLocator));
 }

 public void assertNotChecked(Locator checkBoxLocator)
 {
 assertFalse("Checkbox checked at " + checkBoxLocator.toString(), isChecked(checkBoxLocator));
 }

 public boolean isChecked(Locator checkBoxLocator)
 {
 return checkBoxLocator.findElement(getDriver()).isSelected();
 }

 /**
 * Try to select option by text or value.
 */
 private void selectOption(WebElement el, String text)
 {
 try
 {
 selectOptionByText(el, text);
 }
 catch (NoSuchElementException x)
 {
 selectOptionByValue(el, text);
 }
 }

 public void selectOptionByValue(Locator locator, String value)
 {
 WebElement selectElement = locator.findElement(getDriver());
 selectOptionByValue(selectElement, value);
 }

 public void selectOptionByValue(WebElement selectElement, String value)
 {
 Select select = new Select(selectElement);
 select.selectByValue(value);
 }

 public void selectOptionByText(Locator locator, String text)
 {
 WebElement selectElement = locator.findElement(getDriver());
 selectOptionByText(selectElement, text);
 }

 public void selectOptionByText(WebElement selectElement, String value)
 {
 Select select = new Select(selectElement);
 select.selectByVisibleText(value);
 }

 public void selectOptionByTextContaining(WebElement selectElement, String value)
 {
 Select select = new Select(selectElement);
 List<WebElement> options = select.getOptions();
 List<String> matches = new ArrayList<>();

 for (WebElement option : options)
 {
 String optionText = option.getText();
 if (optionText.contains(value))
 matches.add(optionText);
 }

 if (matches.size() == 1)
 select.selectByVisibleText(matches.getFirst());
 else if (matches.isEmpty())
 select.selectByVisibleText(value);
 else
 fail("Too many matches for '" + value + "': ['" + StringUtils.join(matches, "', '") + "']");

 }
 public void addUrlParameter(String parameter)
 {
 addUrlParameter(parameter, defaultWaitForPage);
 }

 public void addUrlParameter(String parameter, int mils)
 {
 String currentURL = getCurrentRelativeURL();
 // Strip off any '#' on the end of the URL
 String suffix = "";
 if (currentURL.contains("#"))
 {
 String[] parts = currentURL.split("#", 2);
 currentURL = parts[0];
 // There might not be anything after the '#'
 suffix = "#" + (parts.length > 1 ? parts[1] : "");
 }
 if (!currentURL.contains(parameter))
 {
 final String paramSep;
 if (currentURL.contains("?"))
 {
 if (currentURL.indexOf("?") == currentURL.length() - 1)
 paramSep = "";
 else
 paramSep = "&";
 }
 else
 paramSep = "?";

 beginAt(currentURL + paramSep + parameter + suffix, mils);
 }
 }

 public String getUrlParam(String paramName)
 {
 return getUrlParam(paramName, false);
 }

 public String getUrlParam(String paramName, boolean decode)
 {
 Map<String, String> params = getUrlParameters();
 String paramValue = params.get(paramName);

 if (paramValue != null && decode)
 {
 paramValue = URLDecoder.decode(paramValue, StandardCharsets.UTF_8);
 }

 return paramValue;
 }

 /**
 * Parses the URL query of the current page
 * @deprecated Duplicated in {@link WebTestHelper#parseUrlQueryString(String)}. Warning: valueless parameters are
 * handled differently ({@code null} instead of {@code ""})
 * @return Map of encoded URL parameters
 */
 @Deprecated (since = "25.1")
 public Map<String, String> getUrlParameters()
 {
 Map<String, String> params = new HashMap<>();
 String urlQuery = getURL().getQuery();
 if (urlQuery != null)
 {
 String[] urlParams = urlQuery.split("&");
 for (String param : urlParams)
 {
 String[] keyValue = param.split("=");
 if (keyValue.length == 2)
 params.put(keyValue[0].trim(), keyValue[1].trim());
 else if (keyValue.length == 1)
 params.put(keyValue[0], "");
 else
 log("Unable to parse url parameter: " + param);
 }
 }
 return params;
 }

 public void assertAttributeEquals(Locator locator, String attributeName, String value)
 {
 String actual = getAttribute(locator, attributeName);
 assertEquals(value, actual);
 }

 public void assertAttributeEquals(WebElement element, String attributeName, String value)
 {
 String actual = element.getAttribute(attributeName);
 assertEquals(value, actual);
 }

 public void assertAttributeContains(Locator locator, String attributeName, String value)
 {
 String actual = getAttribute(locator, attributeName);
 assertTrue("Expected attribute '" + locator + "@" + attributeName + "' value to contain '" + value + "', but was '" + actual + "' instead.", actual != null && actual.contains(value));
 }

 public void assertAttributeContains(WebElement element, String attributeName, String value)
 {
 String actual = element.getAttribute(attributeName);
 assertTrue("Expected attribute '" + element + "@" + attributeName + "' value to contain '" + value + "', but was '" + actual + "' instead.", actual != null && actual.contains(value));
 }

 public void assertAttributeNotContains(Locator locator, String attributeName, String value)
 {
 String actual = getAttribute(locator, attributeName);
 assertTrue("Expected attribute '" + locator + "@" + attributeName + "' value to not contain '" + value + "', but was '" + actual + "' instead.", actual != null && !actual.contains(value));
 }

 public void assertAttributeNotContains(WebElement element, String attributeName, String value)
 {
 String actual = element.getAttribute(attributeName);
 assertTrue("Expected attribute '" + element + "@" + attributeName + "' value to not contain '" + value + "', but was '" + actual + "' instead.", actual != null && !actual.contains(value));
 }

 public String getAttribute(Locator locator, String attributeName)
 {
 return locator.findElement(getDriver()).getAttribute(attributeName);
 }

 public int getDefaultWaitForPage()
 {
 return defaultWaitForPage;
 }

 public void setDefaultWaitForPage(int defaultWaitForPage)
 {
 this.defaultWaitForPage = defaultWaitForPage;
 }

 public String getHtmlSource()
 {
 try
 {
 return getDriver().getPageSource();
 }
 catch (JavascriptException retry)
 {
 // TypeError: document.documentElement is null
 waitForDocument();
 return getDriver().getPageSource();
 }
 }

 public boolean isExtTreeNodeSelected(String nodeCaption)
 {
 Locator loc = Locator.xpath("//div[contains(./@class,'x-tree-selected')]/a/span[text()='" + nodeCaption + "']");
 return isElementPresent(loc);
 }

 public boolean isExtTreeNodeExpanded(String nodeCaption)
 {
 Locator loc = Locator.xpath("//div[contains(./@class,'x-tree-node-expanded')]/a/span[text()='" + nodeCaption + "']");
 return isElementPresent(loc);
 }

 public void pressTab(Locator l)
 {
 WebElement el = l.findElement(getDriver());
 el.sendKeys(Keys.TAB);
 }

 public void pressEnter(Locator l)
 {
 WebElement el = l.findElement(getDriver());
 el.sendKeys(Keys.ENTER);
 }

 public void pressDownArrow(Locator l)
 {
 WebElement el = l.findElement(getDriver());
 el.sendKeys(Keys.DOWN);
 }

 public void pressUpArrow(Locator l)
 {
 WebElement el = l.findElement(getDriver());
 el.sendKeys(Keys.UP);
 }

 public void setCodeEditorValue(String id, String value)
 {
 new CodeMirrorHelper(this, id).setCodeMirrorValue(value);
 }

 protected String getCodeEditorValue(String id)
 {
 return new CodeMirrorHelper(this, id).getCodeMirrorValue();
 }

 public void waitForElements(final Locator loc, final int count)
 {
 waitForElements(loc, count, WAIT_FOR_JAVASCRIPT);
 }

 public void waitForElements(final Locator loc, final int count, int wait)
 {
 waitFor(() -> count == loc.findElements(getDriver()).size(), wait);
 assertEquals("Element not present expected number of times", count, loc.findElements(getDriver()).size());
 }

 public void clearTooltips()
 {
 // hack, but there might be a tooltip in the way that we need to clear by moving the mouse first
 Locator.XPathLocator headerLoc = Locator.byClass("header-logo");
 if (isElementPresent(headerLoc))
 mouseOver(headerLoc);
 }
}