Add Char case conversion tests

libraries/stdlib/test/text/CharTest.kt

@@ -5,11 +5,7 @@
 
 package test.text
 
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-import kotlin.test.assertFails
+import kotlin.test.*
 
 class CharTest {
 
@@ -301,4 +297,200 @@ class CharTest {
         assertEquals(CharCategory.CONTROL, controlCancel.category)
         assertEquals("Cc", CharCategory.CONTROL.code)
     }
+
+    @Test
+    fun lowercaseChar() {
+        assertEquals('\u0000', '\u0000'.lowercaseChar())
+
+        // ASCII
+        assertEquals('\u0040', '\u0040'.lowercaseChar())
+        for (index in 0..25) { // '\u0041'..'\u005A' -> '\u0061'..'\u007A'
+            assertEquals('a' + index, ('A' + index).lowercaseChar())
+            assertEquals('a' + index, ('a' + index).lowercaseChar())
+        }
+        assertEquals('\u005B', '\u005B'.lowercaseChar())
+
+        // <Lu, Ll>
+        assertEquals('\u0101', '\u0100'.lowercaseChar())
+        assertEquals('\u0101', '\u0101'.lowercaseChar())
+        assertEquals('\u0103', '\u0102'.lowercaseChar())
+
+        // LATIN CAPITAL LETTER I WITH DOT ABOVE
+        assertEquals('\u0069', '\u0130'.lowercaseChar())
+
+        // last mappings
+        assertEquals('\uFF20', '\uFF20'.lowercaseChar())
+        assertEquals('\uFF41', '\uFF21'.lowercaseChar())
+        assertEquals('\uFF5A', '\uFF3A'.lowercaseChar())
+        assertEquals('\uFF3B', '\uFF3B'.lowercaseChar())
+
+        assertEquals('\uFFFF', '\uFFFF'.lowercaseChar())
+    }
+
+    @Test
+    fun uppercaseChar() {
+        assertEquals('\u0000', '\u0000'.uppercaseChar())
+
+        // ASCII
+        assertEquals('\u0060', '\u0060'.uppercaseChar())
+        for (index in 0..25) { // '\u0061'..'\u007A' -> '\u0041'..'\u005A'
+            assertEquals('A' + index, ('a' + index).uppercaseChar())
+            assertEquals('A' + index, ('A' + index).uppercaseChar())
+        }
+        assertEquals('\u007B', '\u007B'.uppercaseChar())
+
+        // <Lu, Ll>
+        assertEquals('\u012C', '\u012D'.uppercaseChar())
+        assertEquals('\u012E', '\u012E'.uppercaseChar())
+        assertEquals('\u012E', '\u012F'.uppercaseChar())
+
+        // LATIN CAPITAL LETTER I WITH DOT ABOVE
+        assertEquals('\u0130', '\u0130'.uppercaseChar())
+
+        // <Ll, x, Ll, ...>
+        assertEquals('\u1F50', '\u1F50'.uppercaseChar())
+        assertEquals('\u1F59', '\u1F51'.uppercaseChar())
+        assertEquals('\u1F5F', '\u1F57'.uppercaseChar())
+        assertEquals('\u1F58', '\u1F58'.uppercaseChar())
+
+        // last mappings
+        assertEquals('\uFF40', '\uFF40'.uppercaseChar())
+        assertEquals('\uFF21', '\uFF41'.uppercaseChar())
+        assertEquals('\uFF3A', '\uFF5A'.uppercaseChar())
+        assertEquals('\uFF5B', '\uFF5B'.uppercaseChar())
+
+        assertEquals('\uFFFF', '\uFFFF'.uppercaseChar())
+    }
+
+    @Test
+    fun titlecaseChar() {
+        assertEquals('\u0000', '\u0000'.titlecaseChar())
+
+        // ASCII
+        assertEquals('\u0060', '\u0060'.titlecaseChar())
+        for (index in 0..25) { // '\u0061'..'\u007A' -> '\u0041'..'\u005A'
+            assertEquals('A' + index, ('a' + index).titlecaseChar())
+            assertEquals('A' + index, ('A' + index).titlecaseChar())
+        }
+        assertEquals('\u007B', '\u007B'.titlecaseChar())
+
+        // <Lu, Lt, Ll>
+        assertEquals('\u01C5', '\u01C4'.titlecaseChar())
+        assertEquals('\u01C5', '\u01C5'.titlecaseChar())
+        assertEquals('\u01C5', '\u01C6'.titlecaseChar())
+        assertEquals('\u01C8', '\u01C7'.titlecaseChar())
+        assertEquals('\u01C8', '\u01C8'.titlecaseChar())
+        assertEquals('\u01C8', '\u01C9'.titlecaseChar())
+        assertEquals('\u01CB', '\u01CA'.titlecaseChar())
+        assertEquals('\u01CB', '\u01CB'.titlecaseChar())
+        assertEquals('\u01CB', '\u01CC'.titlecaseChar())
+
+        // Lu, Lt, Ll
+        assertEquals('\u01F0', '\u01F0'.titlecaseChar())
+        assertEquals('\u01F2', '\u01F1'.titlecaseChar())
+        assertEquals('\u01F2', '\u01F2'.titlecaseChar())
+        assertEquals('\u01F2', '\u01F3'.titlecaseChar())
+        assertEquals('\u01F4', '\u01F4'.titlecaseChar())
+
+        // titlecaseChar == uppercaseChar
+        assertEquals('\uA68D'.uppercaseChar(), '\uA68D'.titlecaseChar())
+        assertEquals('\uA7C3'.uppercaseChar(), '\uA7C3'.titlecaseChar())
+
+        assertEquals('\uFFFF', '\uFFFF'.titlecaseChar())
+    }
+
+    @Test
+    fun lowercase() {
+        assertEquals("\u0000", '\u0000'.lowercase())
+
+        // ASCII
+        assertEquals("\u0040", "\u0040".lowercase())
+        for (index in 0..25) { // '\u0041'..'\u005A' -> '\u0061'..'\u007A'
+            assertEquals(('a' + index).toString(), ('A' + index).lowercase())
+            assertEquals(('a' + index).toString(), ('a' + index).lowercase())
+        }
+        assertEquals("\u005B", '\u005B'.lowercase())
+
+        // lowercase = lowercaseChar != char
+        assertEquals('\u04A6'.lowercaseChar().toString(), '\u04A6'.lowercase())
+        assertNotEquals("\u04A6", '\u04A6'.lowercase())
+
+        // lowercase = lowercaseChar = char
+        assertEquals('\u2CE8'.lowercaseChar().toString(), '\u2CE8'.lowercase())
+        assertEquals("\u2CE8", '\u2CE8'.lowercase())
+
+        assertEquals("\uFFFF", '\uFFFF'.lowercase())
+    }
+
+    @Test
+    fun uppercase() {
+        assertEquals("\u0000", '\u0000'.uppercase())
+
+        // ASCII
+        assertEquals("\u0060", '\u0060'.uppercase())
+        for (index in 0..25) { // '\u0061'..'\u007A' -> '\u0041'..'\u005A'
+            assertEquals(('A' + index).toString(), ('a' + index).uppercase())
+            assertEquals(('A' + index).toString(), ('A' + index).uppercase())
+        }
+        assertEquals("\u007B", '\u007B'.uppercase())
+
+        // LATIN SMALL LETTER SHARP S (ß -> SS)
+        assertEquals("\u0053\u0053", '\u00df'.uppercase())
+
+        // LATIN SMALL LETTER N PRECEDED BY APOSTROPHE (ʼn -> ʼN)
+        assertEquals("\u02BC\u004E", '\u0149'.uppercase())
+
+        // LATIN SMALL LIGATURE FFI (ffi -> FFI)
+        assertEquals("\u0046\u0046\u0049", '\uFB03'.uppercase())
+
+        // uppercase = uppercaseChar != char
+        assertEquals('\u056C'.uppercaseChar().toString(), '\u056C'.uppercase())
+        assertNotEquals("\u056C", '\u056C'.uppercase())
+
+        // uppercase = uppercaseChar == char
+        assertEquals('\u1000'.uppercaseChar().toString(), '\u1000'.uppercase())
+        assertEquals("\u1000", '\u1000'.uppercase())
+
+        assertEquals("\uFFFF", '\uFFFF'.uppercase())
+    }
+
+    @Test
+    fun titlecase() {
+        assertEquals("\u0000", '\u0000'.titlecase())
+
+        // ASCII
+        assertEquals("\u0060", '\u0060'.titlecase())
+        for (index in 0..25) { // '\u0061'..'\u007A' -> '\u0041'..'\u005A'
+            assertEquals(('A' + index).toString(), ('a' + index).titlecase())
+            assertEquals(('A' + index).toString(), ('A' + index).titlecase())
+        }
+        assertEquals("\u007B", '\u007B'.titlecase())
+
+        // LATIN SMALL LETTER SHARP S (ß -> Ss)
+        assertEquals("\u0053\u0073", '\u00df'.titlecase())
+
+        // LATIN SMALL LETTER N PRECEDED BY APOSTROPHE (ʼn -> ʼN)
+        assertEquals("\u02BC\u004E", '\u0149'.titlecase())
+
+        // LATIN SMALL LIGATURE FFI (ffi -> Ffi)
+        assertEquals("\u0046\u0066\u0069", '\uFB03'.titlecase())
+
+        // titlecase = titlecaseChar = uppercaseChar != char
+        assertEquals('\u056C'.titlecaseChar().toString(), '\u056C'.titlecase())
+        assertEquals('\u056C'.uppercaseChar(), '\u056C'.titlecaseChar())
+        assertNotEquals('\u056C', '\u056C'.uppercaseChar())
+
+        // titlecase = titlecaseChar != uppercaseChar != char
+        assertEquals('\u01C6'.titlecaseChar().toString(), '\u01C6'.titlecase())
+        assertNotEquals('\u01C6'.uppercaseChar(), '\u01C6'.titlecaseChar())
+        assertNotEquals('\u01C6', '\u01C6'.titlecaseChar())
+        assertNotEquals('\u01C6', '\u01C6'.uppercaseChar())
+
+        // titlecase = titlecaseChar = uppercaseChar = char
+        assertEquals('\u1000'.titlecaseChar().toString(), '\u1000'.titlecase())
+        assertEquals('\u1000'.uppercaseChar(), '\u1000'.titlecaseChar())
+        assertEquals('\u1000', '\u1000'.uppercaseChar())
+
+        assertEquals("\uFFFF", '\uFFFF'.titlecase())
+    }
 }