Add some support for the code-point code-unit distinction.

runtime/vm/object_test.cc

Index: runtime/vm/object_test.cc
diff --git a/runtime/vm/object_test.cc b/runtime/vm/object_test.cc
index 5117e719b3bbefda35233e13c782e964c6c156e3..d572f41ceeaaf2fed339421a3b3e9522f07488a4 100644
--- a/runtime/vm/object_test.cc
+++ b/runtime/vm/object_test.cc
@@ -273,6 +273,48 @@ TEST_CASE(Smi) {
 }
 
 
+TEST_CASE(StringCompareTo) {
+  const String& abcd = String::Handle(String::New("abcd"));
+  const String& abce = String::Handle(String::New("abce"));
+  EXPECT_EQ(0, abcd.CompareTo(abcd));
+  EXPECT_EQ(0, abce.CompareTo(abce));
+  EXPECT(abcd.CompareTo(abce) < 0);
+  EXPECT(abce.CompareTo(abcd) > 0);
+
+  const int kMonkeyLen = 4;
+  const uint8_t monkey_utf8[kMonkeyLen] = { 0xf0, 0x9f, 0x90, 0xb5 };
+  const String& monkey_face =
+      String::Handle(String::New(monkey_utf8, kMonkeyLen));
+  const int kDogLen = 4;
+  // 0x1f436 DOG FACE.
+  const uint8_t dog_utf8[kDogLen] = { 0xf0, 0x9f, 0x90, 0xb6 };
+  const String& dog_face = String::Handle(String::New(dog_utf8, kDogLen));
+  EXPECT_EQ(0, monkey_face.CompareTo(monkey_face));
+  EXPECT_EQ(0, dog_face.CompareTo(dog_face));
+  EXPECT(monkey_face.CompareTo(dog_face) < 0);
+  EXPECT(dog_face.CompareTo(monkey_face) > 0);
+
+  const int kDominoLen = 4;
+  // 0x1f036 DOMINO TILE HORIZONTAL-00-05.
+  const uint8_t domino_utf8[kDominoLen] = { 0xf0, 0x9f, 0x80, 0xb6 };
+  const String& domino = String::Handle(String::New(domino_utf8, kDominoLen));
+  EXPECT_EQ(0, domino.CompareTo(domino));
+  EXPECT(domino.CompareTo(dog_face) < 0);
+  EXPECT(domino.CompareTo(monkey_face) < 0);
+  EXPECT(dog_face.CompareTo(domino) > 0);
+  EXPECT(monkey_face.CompareTo(domino) > 0);
+
+  EXPECT(abcd.CompareTo(monkey_face) < 0);
+  EXPECT(abce.CompareTo(monkey_face) < 0);
+  EXPECT(abcd.CompareTo(domino) < 0);
+  EXPECT(abce.CompareTo(domino) < 0);
+  EXPECT(domino.CompareTo(abcd) > 0);
+  EXPECT(domino.CompareTo(abcd) > 0);
+  EXPECT(monkey_face.CompareTo(abce) > 0);
+  EXPECT(monkey_face.CompareTo(abce) > 0);
+}
+
+
 TEST_CASE(Mint) {
 // On 64-bit architectures a Smi is stored in a 64 bit word. A Midint cannot
 // be allocated if it does fit into a Smi.
@@ -462,6 +504,9 @@ TEST_CASE(Integer) {
 }
 
 
+static unsigned char ToUChar(char x) { return static_cast<unsigned char>(x); }
+
+
 TEST_CASE(String) {
   const char* kHello = "Hello World!";
   int32_t hello_len = strlen(kHello);
@@ -472,27 +517,27 @@ TEST_CASE(String) {
   EXPECT(!str.IsTwoByteString());
   EXPECT(!str.IsNumber());
   EXPECT_EQ(hello_len, str.Length());
-  EXPECT_EQ('H', str.CharAt(0));
-  EXPECT_EQ('e', str.CharAt(1));
-  EXPECT_EQ('l', str.CharAt(2));
-  EXPECT_EQ('l', str.CharAt(3));
-  EXPECT_EQ('o', str.CharAt(4));
-  EXPECT_EQ(' ', str.CharAt(5));
-  EXPECT_EQ('W', str.CharAt(6));
-  EXPECT_EQ('o', str.CharAt(7));
-  EXPECT_EQ('r', str.CharAt(8));
-  EXPECT_EQ('l', str.CharAt(9));
-  EXPECT_EQ('d', str.CharAt(10));
-  EXPECT_EQ('!', str.CharAt(11));
+  EXPECT_EQ(ToUChar('H'), str.CodeUnitAt(0));
+  EXPECT_EQ(ToUChar('e'), str.CodeUnitAt(1));
+  EXPECT_EQ(ToUChar('l'), str.CodeUnitAt(2));
+  EXPECT_EQ(ToUChar('l'), str.CodeUnitAt(3));
+  EXPECT_EQ(ToUChar('o'), str.CodeUnitAt(4));
+  EXPECT_EQ(ToUChar(' '), str.CodeUnitAt(5));
+  EXPECT_EQ(ToUChar('W'), str.CodeUnitAt(6));
+  EXPECT_EQ(ToUChar('o'), str.CodeUnitAt(7));
+  EXPECT_EQ(ToUChar('r'), str.CodeUnitAt(8));
+  EXPECT_EQ(ToUChar('l'), str.CodeUnitAt(9));
+  EXPECT_EQ(ToUChar('d'), str.CodeUnitAt(10));
+  EXPECT_EQ(ToUChar('!'), str.CodeUnitAt(11));
 
   const uint8_t* motto =
       reinterpret_cast<const uint8_t*>("Dart's bescht wos je hets gits");
   const String& str2 = String::Handle(String::New(motto+7, 4));
   EXPECT_EQ(4, str2.Length());
-  EXPECT_EQ('b', str2.CharAt(0));
-  EXPECT_EQ('e', str2.CharAt(1));
-  EXPECT_EQ('s', str2.CharAt(2));
-  EXPECT_EQ('c', str2.CharAt(3));
+  EXPECT_EQ(ToUChar('b'), str2.CodeUnitAt(0));
+  EXPECT_EQ(ToUChar('e'), str2.CodeUnitAt(1));
+  EXPECT_EQ(ToUChar('s'), str2.CodeUnitAt(2));
+  EXPECT_EQ(ToUChar('c'), str2.CodeUnitAt(3));
 
   const String& str3 = String::Handle(String::New(kHello));
   EXPECT(str.Equals(str));
@@ -517,20 +562,20 @@ TEST_CASE(String) {
   const uint8_t chars[kCharsLen] = { 1, 2, 127, 64, 92, 0, 55, 55 };
   const String& str8 = String::Handle(String::New(chars, kCharsLen));
   EXPECT_EQ(kCharsLen, str8.Length());
-  EXPECT_EQ(1, str8.CharAt(0));
-  EXPECT_EQ(127, str8.CharAt(2));
-  EXPECT_EQ(64, str8.CharAt(3));
-  EXPECT_EQ(0, str8.CharAt(5));
-  EXPECT_EQ(55, str8.CharAt(6));
-  EXPECT_EQ(55, str8.CharAt(7));
+  EXPECT_EQ(1u, str8.CodeUnitAt(0));
+  EXPECT_EQ(127u, str8.CodeUnitAt(2));
+  EXPECT_EQ(64u, str8.CodeUnitAt(3));
+  EXPECT_EQ(0u, str8.CodeUnitAt(5));
+  EXPECT_EQ(55u, str8.CodeUnitAt(6));
+  EXPECT_EQ(55u, str8.CodeUnitAt(7));
   const intptr_t kCharsIndex = 3;
   const String& sub1 = String::Handle(String::SubString(str8, kCharsIndex));
   EXPECT_EQ((kCharsLen - kCharsIndex), sub1.Length());
-  EXPECT_EQ(64, sub1.CharAt(0));
-  EXPECT_EQ(92, sub1.CharAt(1));
-  EXPECT_EQ(0, sub1.CharAt(2));
-  EXPECT_EQ(55, sub1.CharAt(3));
-  EXPECT_EQ(55, sub1.CharAt(4));
+  EXPECT_EQ(64u, sub1.CodeUnitAt(0));
+  EXPECT_EQ(92u, sub1.CodeUnitAt(1));
+  EXPECT_EQ(0u, sub1.CodeUnitAt(2));
+  EXPECT_EQ(55u, sub1.CodeUnitAt(3));
+  EXPECT_EQ(55u, sub1.CodeUnitAt(4));
 
   const intptr_t kWideCharsLen = 7;
   uint16_t wide_chars[kWideCharsLen] = { 'H', 'e', 'l', 'l', 'o', 256, '!' };
@@ -541,15 +586,15 @@ TEST_CASE(String) {
   EXPECT(two_str.IsTwoByteString());
   EXPECT(!two_str.IsOneByteString());
   EXPECT_EQ(kWideCharsLen, two_str.Length());
-  EXPECT_EQ('H', two_str.CharAt(0));
-  EXPECT_EQ(256, two_str.CharAt(5));
+  EXPECT_EQ(ToUChar('H'), two_str.CodeUnitAt(0));
+  EXPECT_EQ(256u, two_str.CodeUnitAt(5));
   const intptr_t kWideCharsIndex = 3;
   const String& sub2 = String::Handle(String::SubString(two_str, kCharsIndex));
   EXPECT_EQ((kWideCharsLen - kWideCharsIndex), sub2.Length());
-  EXPECT_EQ('l', sub2.CharAt(0));
-  EXPECT_EQ('o', sub2.CharAt(1));
-  EXPECT_EQ(256, sub2.CharAt(2));
-  EXPECT_EQ('!', sub2.CharAt(3));
+  EXPECT_EQ(ToUChar('l'), sub2.CodeUnitAt(0));
+  EXPECT_EQ(ToUChar('o'), sub2.CodeUnitAt(1));
+  EXPECT_EQ(256u, sub2.CodeUnitAt(2));
+  EXPECT_EQ(ToUChar('!'), sub2.CodeUnitAt(3));
 
   {
     const String& str1 = String::Handle(String::New("My.create"));
@@ -565,14 +610,14 @@ TEST_CASE(String) {
   EXPECT(four_str.IsTwoByteString());
   EXPECT(!four_str.IsOneByteString());
   EXPECT_EQ(8, four_str.Length());
-  EXPECT_EQ('C', four_str.CharAt(0));
-  EXPECT_EQ(0xFF, four_str.CharAt(1));
-  EXPECT_EQ('h', four_str.CharAt(2));
-  EXPECT_EQ(0xFFFF, four_str.CharAt(3));
-  EXPECT_EQ('a', four_str.CharAt(4));
-  EXPECT_EQ(0xDBFF, four_str.CharAt(5));
-  EXPECT_EQ(0xDFFF, four_str.CharAt(6));
-  EXPECT_EQ('r', four_str.CharAt(7));
+  EXPECT_EQ(ToUChar('C'), four_str.CodeUnitAt(0));
+  EXPECT_EQ(0xFFu, four_str.CodeUnitAt(1));
+  EXPECT_EQ(ToUChar('h'), four_str.CodeUnitAt(2));
+  EXPECT_EQ(0xFFFFu, four_str.CodeUnitAt(3));
+  EXPECT_EQ(ToUChar('a'), four_str.CodeUnitAt(4));
+  EXPECT_EQ(0xDBFFu, four_str.CodeUnitAt(5));
+  EXPECT_EQ(0xDFFFu, four_str.CodeUnitAt(6));
+  EXPECT_EQ(ToUChar('r'), four_str.CodeUnitAt(7));
 
   // Create a 1-byte string from an array of 2-byte elements.
   {
@@ -580,9 +625,9 @@ TEST_CASE(String) {
     const String& str8 = String::Handle(String::New(char16, 3));
     EXPECT(str8.IsOneByteString());
     EXPECT(!str8.IsTwoByteString());
-    EXPECT_EQ(0x00, str8.CharAt(0));
-    EXPECT_EQ(0x1F, str8.CharAt(1));
-    EXPECT_EQ(0x7F, str8.CharAt(2));
+    EXPECT_EQ(0x00u, str8.CodeUnitAt(0));
+    EXPECT_EQ(0x1Fu, str8.CodeUnitAt(1));
+    EXPECT_EQ(0x7Fu, str8.CodeUnitAt(2));
   }
 
   // Create a 1-byte string from an array of 4-byte elements.
@@ -591,9 +636,9 @@ TEST_CASE(String) {
     const String& str8 = String::Handle(String::New(char32, 3));
     EXPECT(str8.IsOneByteString());
     EXPECT(!str8.IsTwoByteString());
-    EXPECT_EQ(0x00, str8.CharAt(0));
-    EXPECT_EQ(0x1F, str8.CharAt(1));
-    EXPECT_EQ(0x7F, str8.CharAt(2));
+    EXPECT_EQ(0x00u, str8.CodeUnitAt(0));
+    EXPECT_EQ(0x1Fu, str8.CodeUnitAt(1));
+    EXPECT_EQ(0x7Fu, str8.CodeUnitAt(2));
   }
 
   // Create a 2-byte string from an array of 4-byte elements.
@@ -602,9 +647,9 @@ TEST_CASE(String) {
     const String& str16 = String::Handle(String::New(char32, 3));
     EXPECT(!str16.IsOneByteString());
     EXPECT(str16.IsTwoByteString());
-    EXPECT_EQ(0x0000, str16.CharAt(0));
-    EXPECT_EQ(0x7FFF, str16.CharAt(1));
-    EXPECT_EQ(0xFFFF, str16.CharAt(2));
+    EXPECT_EQ(0x0000u, str16.CodeUnitAt(0));
+    EXPECT_EQ(0x7FFFu, str16.CodeUnitAt(1));
+    EXPECT_EQ(0xFFFFu, str16.CodeUnitAt(2));
   }
 }
 
@@ -1265,7 +1310,7 @@ TEST_CASE(StringFromUtf8Literal) {
     intptr_t expected_length = sizeof(expected);
     EXPECT_EQ(expected_length, str.Length());
     for (int i = 0; i < str.Length(); ++i) {
-      EXPECT_EQ(expected[i], str.CharAt(i));
+      EXPECT_EQ(expected[i], str.CodeUnitAt(i));
     }
   }
 
@@ -1283,7 +1328,7 @@ TEST_CASE(StringFromUtf8Literal) {
     intptr_t expected_size = sizeof(expected) / sizeof(expected[0]);
     EXPECT_EQ(expected_size, str.Length());
     for (int i = 0; i < str.Length(); ++i) {
-      EXPECT_EQ(expected[i], str.CharAt(i));
+      EXPECT_EQ(expected[i], str.CodeUnitAt(i));
     }
   }
 
@@ -1298,7 +1343,7 @@ TEST_CASE(StringFromUtf8Literal) {
         "\x80\xE0\xBC\x80\xEA\x80\x80\xEB"
         "\x80\x80\xEC\x80\x80\xED\x80\x80"
         "\xEE\x80\x80\xEF\x80\x80";
-    const intptr_t expected[] = {
+    const uint32_t expected[] = {
       0x000A, 0x000B, 0x000D, 0x000C, 0x000E, 0x000F, 0x00A0, 0x00B0,
       0x00C0, 0x00D0, 0x00E0, 0x00F0, 0x0A00, 0x0B00, 0x0C00, 0x0D00,
       0x0E00, 0x0F00, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000
@@ -1308,7 +1353,7 @@ TEST_CASE(StringFromUtf8Literal) {
     intptr_t expected_size = sizeof(expected) / sizeof(expected[0]);
     EXPECT_EQ(expected_size, str.Length());
     for (int i = 0; i < str.Length(); ++i) {
-      EXPECT_EQ(expected[i], str.CharAt(i));
+      EXPECT_EQ(expected[i], str.CodeUnitAt(i));
     }
   }
 
@@ -1317,14 +1362,14 @@ TEST_CASE(StringFromUtf8Literal) {
     const char* src =
         "\xF0\x9D\x91\xA0\xF0\x9D\x91\xA1"
         "\xF0\x9D\x91\xA2\xF0\x9D\x91\xA3";
-    const intptr_t expected[] = { 0xd835, 0xdc60, 0xd835, 0xdc61,
+    const uint32_t expected[] = { 0xd835, 0xdc60, 0xd835, 0xdc61,
                                   0xd835, 0xdc62, 0xd835, 0xdc63 };
     const String& str = String::Handle(String::New(src));
     EXPECT(str.IsTwoByteString());
     intptr_t expected_size = (sizeof(expected) / sizeof(expected[0]));
     EXPECT_EQ(expected_size, str.Length());
     for (int i = 0; i < str.Length(); ++i) {
-      EXPECT_EQ(expected[i], str.CharAt(i));
+      EXPECT_EQ(expected[i], str.CodeUnitAt(i));
     }
   }
 
@@ -1339,7 +1384,7 @@ TEST_CASE(StringFromUtf8Literal) {
         "\x80\xEF\x80\x80\xF0\x9A\x80\x80"
         "\xF0\x9B\x80\x80\xF0\x9D\x80\x80"
         "\xF0\x9E\x80\x80\xF0\x9F\x80\x80";
-    const intptr_t expected[] = {
+    const uint32_t expected[] = {
       0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00, 0xA000, 0xB000, 0xC000,
       0xD000, 0xE000, 0xF000, 0xD828, 0xDC00, 0xD82c, 0xDC00, 0xD834, 0xDC00,
       0xD838, 0xDC00, 0xD83c, 0xDC00,
@@ -1349,7 +1394,7 @@ TEST_CASE(StringFromUtf8Literal) {
     intptr_t expected_size = sizeof(expected) / sizeof(expected[0]);
     EXPECT_EQ(expected_size, str.Length());
     for (int i = 0; i < str.Length(); ++i) {
-      EXPECT_EQ(expected[i], str.CharAt(i));
+      EXPECT_EQ(expected[i], str.CodeUnitAt(i));
     }
   }
 
@@ -1367,7 +1412,7 @@ TEST_CASE(StringFromUtf8Literal) {
         "\x80\x80\xF0\x9B\x80\x80\xF0\x9D"
         "\x80\x80\xF0\x9E\x80\x80\xF0\x9F"
         "\x80\x80";
-    const intptr_t expected[] = {
+    const uint32_t expected[] = {
       0x000A, 0x000B, 0x000D, 0x000C, 0x000E, 0x000F, 0x00A0, 0x00B0,
       0x00C0, 0x00D0, 0x00E0, 0x00F0, 0x0A00, 0x0B00, 0x0C00, 0x0D00,
       0x0E00, 0x0F00, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000,
@@ -1379,7 +1424,7 @@ TEST_CASE(StringFromUtf8Literal) {
     intptr_t expected_size = sizeof(expected) / sizeof(expected[0]);
     EXPECT_EQ(expected_size, str.Length());
     for (int i = 0; i < str.Length(); ++i) {
-      EXPECT_EQ(expected[i], str.CharAt(i));
+      EXPECT_EQ(expected[i], str.CodeUnitAt(i));
     }
   }
 }
@@ -1980,14 +2025,14 @@ TEST_CASE(Script) {
   EXPECT(script.IsScript());
   String& str = String::Handle(script.url());
   EXPECT_EQ(17, str.Length());
-  EXPECT_EQ('b', str.CharAt(0));
-  EXPECT_EQ(':', str.CharAt(7));
-  EXPECT_EQ('e', str.CharAt(16));
+  EXPECT_EQ(ToUChar('b'), str.CodeUnitAt(0));
+  EXPECT_EQ(ToUChar(':'), str.CodeUnitAt(7));
+  EXPECT_EQ(ToUChar('e'), str.CodeUnitAt(16));
   str = script.Source();
   EXPECT_EQ(22, str.Length());
-  EXPECT_EQ('T', str.CharAt(0));
-  EXPECT_EQ('n', str.CharAt(10));
-  EXPECT_EQ('.', str.CharAt(21));
+  EXPECT_EQ(ToUChar('T'), str.CodeUnitAt(0));
+  EXPECT_EQ(ToUChar('n'), str.CodeUnitAt(10));
+  EXPECT_EQ(ToUChar('.'), str.CodeUnitAt(21));
 }
 
 
@@ -2227,7 +2272,7 @@ TEST_CASE(EmbedStringInCode) {
   string_object ^= reinterpret_cast<RawInstructions*>(retval);
   EXPECT(string_object.Length() == expected_length);
   for (int i = 0; i < expected_length; i ++) {
-    EXPECT(string_object.CharAt(i) == kHello[i]);
+    EXPECT(string_object.CodeUnitAt(i) == static_cast<uint32_t>(kHello[i]));
   }
 }