Make more Locators work with tricky characters (#2409)

- Consistently normalize whitespace of strings
- Support a wider set of characters for case-insensitive text matching

Author: labkey-tchad

src/org/labkey/test/Locator.java

@@ -46,8 +46,10 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
@@ -975,6 +977,16 @@ public static String xq(String value)
         return Quotes.escape(value);
     }
 
+    /**
+     * Equivalent to XPath {@code normalize-space()}:<br>
+     * "The normalize-space function strips leading and trailing white-space from a string, replaces sequences of
+     * whitespace characters by a single space, and returns the resulting string."
+     */
+    private static String ns(String value)
+    {
+        return value.replaceAll("\\s+", " ").trim();
+    }
+
     public static String cq(String value)
     {
         return "\"" + value.replace("\\", "\\\\").replace("\"", "\\\"") + "\"";
@@ -1189,36 +1201,36 @@ protected XPathLocator(@Language("XPath") String loc)
         public XPathLocator containing(String contains)
         {
             if (contains != null && !contains.isEmpty())
-                return this.withPredicate("contains(normalize-space(), "+xq(contains)+")");
+                return this.withPredicate("contains(normalize-space(), "+xq(ns(contains))+")");
             else
                 return this;
         }
 
         public XPathLocator containingIgnoreCase(String contains)
         {
             if (contains != null && !contains.isEmpty())
-                return this.withPredicate("contains(translate(normalize-space(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), "+xq(contains.toLowerCase())+")");
+                return this.withPredicate("contains(" + toLowerCase("normalize-space()", contains) + ", "+xq(ns(contains.toLowerCase()))+")");
             else
                 return this;
         }
 
         public XPathLocator notContaining(String contains)
         {
-            return this.withPredicate("not(contains(normalize-space(), "+xq(contains)+"))");
+            return this.withPredicate("not(contains(normalize-space(), "+xq(ns(contains))+"))");
         }
 
         public XPathLocator notContainingIgnoreCase(String contains)
         {
             if (contains != null && !contains.isEmpty())
-                return this.withPredicate("not(contains(translate(normalize-space(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), "+xq(contains.toLowerCase())+"))");
+                return this.withPredicate("not(contains(" + toLowerCase("normalize-space()", contains) + ", "+xq(ns(contains.toLowerCase()))+"))");
             else
                 return this;
         }
 
         @Override
         public XPathLocator withText(String text)
         {
-            return this.withPredicate("normalize-space()="+xq(text));
+            return this.withPredicate("normalize-space()="+xq(ns(text)));
         }
 
         public XPathLocator withText()
@@ -1228,7 +1240,7 @@ public XPathLocator withText()
 
         public XPathLocator withoutText(String text)
         {
-            return this.withPredicate("not(normalize-space()=" + xq(text) + ")");
+            return this.withPredicate("not(normalize-space()=" + xq(ns(text)) + ")");
         }
 
         public XPathLocator withoutText()
@@ -1238,17 +1250,17 @@ public XPathLocator withoutText()
 
         public XPathLocator withTextMatching(String regex)
         {
-            return this.withPredicate("matches(normalize-space(), " + xq(regex) + ")");
+            return this.withPredicate("matches(normalize-space(), " + xq(ns(regex)) + ")");
         }
 
         public XPathLocator startsWith(String text)
         {
-            return this.withPredicate("starts-with(normalize-space(), "+xq(text)+")");
+            return this.withPredicate("starts-with(normalize-space(), "+xq(ns(text))+")");
         }
 
         public XPathLocator startsWithIgnoreCase(String text)
         {
-            return this.withPredicate("starts-with(translate(normalize-space(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), "+xq(text.toLowerCase())+")");
+            return this.withPredicate("starts-with(" + toLowerCase("normalize-space()", text) + ", "+xq(ns(text.toLowerCase()))+")");
         }
 
         @Override
@@ -1404,7 +1416,7 @@ public XPathLocator withAttributeMatchingOtherElementAttribute(String attribute,
 
         public XPathLocator endsWith(String substring)
         {
-            return this.endsWith("normalize-space()", substring);
+            return this.endsWith("normalize-space()", ns(substring));
         }
 
         private XPathLocator endsWith(String expression, String substring)
@@ -1451,9 +1463,48 @@ public XPathLocator withAttributeContaining(String attrName, String partialAttrV
 
         public XPathLocator withAttributeIgnoreCase(String attrName, String attrVal)
         {
-            return this.withPredicate(
-                    String.format("translate(@%s, 'ABCDEFGHIJKLMNOPQRSTUVWXYZÅ', 'abcdefghijklmnopqrstuvwxyzå')=%s",
-                            attrName, xq(attrVal.toLowerCase())));
+            return this.withPredicate(toLowerCase("@" + attrName, attrVal) + "=" + xq(attrVal.toLowerCase()));
+        }
+
+        /**
+         * Generate an XPath 'translate' statement that will convert the provided statement to lowerCase so that it can
+         * be compared to the target value. Allow case-insensitive comparison with values containing tricky characters.
+         * The Locator "{@code Locator.tag("span").containingIgnoreCase("test")}", produces an XPath like:
+         * "{@code //span[contains(translate(normalize-space(), 'TES', 'tes'), 'test')]}"<br>
+         * This would find "{@code <span>test</span}" or "{@code <span>TESTING</span}"
+         *
+         * @param sourceStatement XPath statement to apply the translation to
+         * @param targetValue String that 'sourceStatement' will be compared to
+         * @return translate statement to be used in XPath predicate
+         */
+        private String toLowerCase(String sourceStatement, String targetValue)
+        {
+            Map<Character, Character> caseMap = new HashMap<>(); // upperCase -> lowerCase
+            char[] upperCase = targetValue.toUpperCase().toCharArray();
+            char[] lowerCase = targetValue.toLowerCase().toCharArray();
+            for (int i = 0; i < targetValue.length(); i++)
+            {
+                if (upperCase[i] != lowerCase[i])
+                {
+                    caseMap.put(Character.valueOf(upperCase[i]), Character.valueOf(lowerCase[i]));
+                }
+            }
+            if (caseMap.isEmpty())
+            {
+                return sourceStatement;
+            }
+            else
+            {
+                StringBuilder upperCaseBuilder = new StringBuilder();
+                StringBuilder lowerCaseBuilder = new StringBuilder();
+                caseMap.forEach((u, l) -> {
+                    upperCaseBuilder.append(u);
+                    lowerCaseBuilder.append(l);
+                });
+                return "translate(" + sourceStatement + ", " +
+                        "'" + upperCaseBuilder + "' ," +
+                        "'" + lowerCaseBuilder + "')";
+            }
         }
 
         public XPathLocator withoutAttribute(String attrName, String attrVal)