Rename methods: trimLeft/Right -> trimStart/End, padLeft/Right -> padStart/End

libraries/stdlib/test/text/StringTest.kt

@@ -153,45 +153,45 @@ class StringTest {
         assertTrue(sum == 14)
     }
 
-    test fun trimLeading() {
-        assertEquals("", "".trimLeading())
-        assertEquals("a", "a".trimLeading())
-        assertEquals("a", " a".trimLeading())
-        assertEquals("a", "  a".trimLeading())
-        assertEquals("a  ", "  a  ".trimLeading())
-        assertEquals("a b", "  a b".trimLeading())
-        assertEquals("a b ", "  a b ".trimLeading())
-        assertEquals("a", " \u00A0 a".trimLeading())
+    test fun trimStart() {
+        assertEquals("", "".trimStart())
+        assertEquals("a", "a".trimStart())
+        assertEquals("a", " a".trimStart())
+        assertEquals("a", "  a".trimStart())
+        assertEquals("a  ", "  a  ".trimStart())
+        assertEquals("a b", "  a b".trimStart())
+        assertEquals("a b ", "  a b ".trimStart())
+        assertEquals("a", " \u00A0 a".trimStart())
 
-        assertEquals("a", "\ta".trimLeading())
-        assertEquals("a", "\t\ta".trimLeading())
-        assertEquals("a", "\ra".trimLeading())
-        assertEquals("a", "\na".trimLeading())
+        assertEquals("a", "\ta".trimStart())
+        assertEquals("a", "\t\ta".trimStart())
+        assertEquals("a", "\ra".trimStart())
+        assertEquals("a", "\na".trimStart())
 
-        assertEquals("a=", "-=-=a=".trimLeading('-','='))
-        assertEquals("123a", "ab123a".trimLeading { it < '0' || it > '9' }) // TODO: Use !it.isDigit when available in JS
+        assertEquals("a=", "-=-=a=".trimStart('-','='))
+        assertEquals("123a", "ab123a".trimStart { it < '0' || it > '9' }) // TODO: Use !it.isDigit when available in JS
     }
 
-    test fun trimTrailing() {
-        assertEquals("", "".trimTrailing())
-        assertEquals("a", "a".trimTrailing())
-        assertEquals("a", "a ".trimTrailing())
-        assertEquals("a", "a  ".trimTrailing())
-        assertEquals("  a", "  a  ".trimTrailing())
-        assertEquals("a b", "a b  ".trimTrailing())
-        assertEquals(" a b", " a b  ".trimTrailing())
-        assertEquals("a", "a \u00A0 ".trimTrailing())
+    test fun trimEnd() {
+        assertEquals("", "".trimEnd())
+        assertEquals("a", "a".trimEnd())
+        assertEquals("a", "a ".trimEnd())
+        assertEquals("a", "a  ".trimEnd())
+        assertEquals("  a", "  a  ".trimEnd())
+        assertEquals("a b", "a b  ".trimEnd())
+        assertEquals(" a b", " a b  ".trimEnd())
+        assertEquals("a", "a \u00A0 ".trimEnd())
 
-        assertEquals("a", "a\t".trimTrailing())
-        assertEquals("a", "a\t\t".trimTrailing())
-        assertEquals("a", "a\r".trimTrailing())
-        assertEquals("a", "a\n".trimTrailing())
+        assertEquals("a", "a\t".trimEnd())
+        assertEquals("a", "a\t\t".trimEnd())
+        assertEquals("a", "a\r".trimEnd())
+        assertEquals("a", "a\n".trimEnd())
 
-        assertEquals("=a", "=a=-=-".trimTrailing('-','='))
-        assertEquals("ab123", "ab123a".trimTrailing { it < '0' || it > '9' }) // TODO: Use !it.isDigit when available in JS
+        assertEquals("=a", "=a=-=-".trimEnd('-','='))
+        assertEquals("ab123", "ab123a".trimEnd { it < '0' || it > '9' }) // TODO: Use !it.isDigit when available in JS
     }
 
-    test fun trimTrailingAndLeading() {
+    test fun trimStartAndEnd() {
         val examples = array(
                 "a",
                 " a ",
@@ -205,8 +205,8 @@ class StringTest {
         )
 
         for (example in examples) {
-            assertEquals(example.trim(), example.trimTrailing().trimLeading())
-            assertEquals(example.trim(), example.trimLeading().trimTrailing())
+            assertEquals(example.trim(), example.trimEnd().trimStart())
+            assertEquals(example.trim(), example.trimStart().trimEnd())
         }
 
         val examplesForPredicate = array(
@@ -217,28 +217,28 @@ class StringTest {
         val trimChars = charArray('-','=')
         val trimPredicate = { (it: Char) -> it < '0' || it > '9' } // TODO: Use !it.isDigit when available in JS
         for (example in examplesForPredicate) {
-            assertEquals(example.trimLeading(*trimChars).trimTrailing(*trimChars), example.trim(*trimChars))
-            assertEquals(example.trimLeading(trimPredicate).trimTrailing(trimPredicate), example.trim(trimPredicate))
+            assertEquals(example.trimStart(*trimChars).trimEnd(*trimChars), example.trim(*trimChars))
+            assertEquals(example.trimStart(trimPredicate).trimEnd(trimPredicate), example.trim(trimPredicate))
         }
     }
 
-    test fun padLeft() {
-        assertEquals("s", "s".padLeft(0))
-        assertEquals("s", "s".padLeft(1))
-        assertEquals("  ", "".padLeft(2))
-        assertEquals("--s", "s".padLeft(3, '-'))
+    test fun padStart() {
+        assertEquals("s", "s".padStart(0))
+        assertEquals("s", "s".padStart(1))
+        assertEquals("  ", "".padStart(2))
+        assertEquals("--s", "s".padStart(3, '-'))
         fails {
-            "s".padLeft(-1)
+            "s".padStart(-1)
         }
     }
 
-    test fun padRight() {
-        assertEquals("s", "s".padRight(0))
-        assertEquals("s", "s".padRight(1))
-        assertEquals("  ", "".padRight(2))
-        assertEquals("s--", "s".padRight(3, '-'))
+    test fun padEnd() {
+        assertEquals("s", "s".padEnd(0))
+        assertEquals("s", "s".padEnd(1))
+        assertEquals("  ", "".padEnd(2))
+        assertEquals("s--", "s".padEnd(3, '-'))
         fails {
-            "s".padRight(-1)
+            "s".padEnd(-1)
         }
     }
 
@@ -256,12 +256,12 @@ class StringTest {
         assertEquals("sample", "sample".removeSuffix(""))
     }
 
-    test fun removeEnclosing() {
-        assertEquals("value", "<value>".removeEnclosing("<", ">"))
-        assertEquals("<value>", "<<value>>".removeEnclosing("<", ">"), "Removes enclosing once")
-        assertEquals("<value", "<value".removeEnclosing("<", ">"), "Only removes enclosing when both prefix and suffix present")
-        assertEquals("value>", "value>".removeEnclosing("<", ">"), "Only removes enclosing when both prefix and suffix present")
-        assertEquals("value", "value".removeEnclosing("<", ">"))
+    test fun removeSurrounding() {
+        assertEquals("value", "<value>".removeSurrounding("<", ">"))
+        assertEquals("<value>", "<<value>>".removeSurrounding("<", ">"), "Removes surrounding once")
+        assertEquals("<value", "<value".removeSurrounding("<", ">"), "Only removes surrounding when both prefix and suffix present")
+        assertEquals("value>", "value>".removeSurrounding("<", ">"), "Only removes surrounding when both prefix and suffix present")
+        assertEquals("value", "value".removeSurrounding("<", ">"))
     }
 
 }