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

runtime/vm/object_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 255 matching lines @@
       "10000000000000000000"));
   Bigint& big2 = Bigint::Handle(BigintOperations::NewFromCString(
       "-10000000000000000000"));
   EXPECT_EQ(-1, a.CompareWith(big1));
   EXPECT_EQ(1, a.CompareWith(big2));
   EXPECT_EQ(-1, c.CompareWith(big1));
   EXPECT_EQ(1, c.CompareWith(big2));
 }
 
 
+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.
 #if !defined(ARCH_IS_64_BIT)
   { Mint& med = Mint::Handle();
     EXPECT(med.IsNull());
     int64_t v = DART_2PART_UINT64_C(1, 0);
     med = Mint::New(v);
     EXPECT_EQ(v, med.value());
     const String& smi_str = String::Handle(String::New("1"));
@@ skipping 169 matching lines @@
   EXPECT(i.IsSmi());
   i = Integer::New(String::Handle(String::New("0")));
   EXPECT(i.IsSmi());
   i = Integer::New(String::Handle(String::New("12345678901234567890")));
   EXPECT(i.IsBigint());
   i = Integer::New(String::Handle(String::New("-12345678901234567890111222")));
   EXPECT(i.IsBigint());
 }
 
 
+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);
   const String& str = String::Handle(String::New(kHello));
   EXPECT(str.IsInstance());
   EXPECT(str.IsString());
   EXPECT(str.IsOneByteString());
   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));
   EXPECT_EQ(str.Hash(), str.Hash());
   EXPECT(!str.Equals(str2));
   EXPECT(str.Equals(str3));
   EXPECT_EQ(str.Hash(), str3.Hash());
   EXPECT(str3.Equals(str));
 
   const String& str4 = String::Handle(String::New("foo"));
   const String& str5 = String::Handle(String::New("bar"));
   const String& str6 = String::Handle(String::Concat(str4, str5));
   const String& str7 = String::Handle(String::New("foobar"));
   EXPECT(str6.Equals(str7));
   EXPECT(!str6.Equals(Smi::Handle(Smi::New(4))));
 
   const String& empty1 = String::Handle(String::New(""));
   const String& empty2 = String::Handle(String::New(""));
   EXPECT(empty1.Equals(empty2, 0, 0));
 
   const intptr_t kCharsLen = 8;
   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, '!' };
   const String& two_str = String::Handle(String::New(wide_chars,
                                                      kWideCharsLen));
   EXPECT(two_str.IsInstance());
   EXPECT(two_str.IsString());
   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"));
     const String& str2 = String::Handle(String::New("My"));
     const String& str3 = String::Handle(String::New("create"));
     EXPECT_EQ(true, str1.StartsWith(str2));
     EXPECT_EQ(false, str1.StartsWith(str3));
   }
 
   const uint32_t four_chars[] = { 'C', 0xFF, 'h', 0xFFFF, 'a', 0x10FFFF, 'r' };
   const String& four_str = String::Handle(String::New(four_chars, 7));
   EXPECT_EQ(four_str.Hash(), four_str.Hash());
   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.
   {
     const uint16_t char16[] = { 0x00, 0x1F, 0x7F };
     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.
   {
     const uint32_t char32[] = { 0x00, 0x1F, 0x7F };
     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.
   {
     const uint32_t char32[] = { 0, 0x7FFF, 0xFFFF };
     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));
   }
 }
 
 
 TEST_CASE(StringFormat) {
   const char* hello_str = "Hello World!";
   const String& str =
       String::Handle(String::NewFormatted("Hello %s!", "World"));
   EXPECT(str.IsInstance());
   EXPECT(str.IsString());
@@ skipping 640 matching lines @@
       0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
       0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
       0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
       0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
     };
     const String& str = String::Handle(String::New(src));
     EXPECT(str.IsTwoByteString());
     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));
     }
   }
 
   // Create a 2-byte string from a UTF-8 encoded string literal.
   {
     const char* src =
         "\xD7\x92\xD7\x9C\xD7\xA2\xD7\x93"
         "\xD7\x91\xD7\xA8\xD7\x9B\xD7\x94";
     const uint16_t expected[] = {
       0x5D2, 0x5DC, 0x5E2, 0x5D3,
       0x5D1, 0x5E8, 0x5DB, 0x5D4
     };
     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));
     }
   }
 
   // Create a BMP 2-byte string from UTF-8 encoded 1- and 2-byte
   // characters.
   {
     const char* src =
         "\x0A\x0B\x0D\x0C\x0E\x0F\xC2\xA0"
         "\xC2\xB0\xC3\x80\xC3\x90\xC3\xA0"
         "\xC3\xB0\xE0\xA8\x80\xE0\xAC\x80"
         "\xE0\xB0\x80\xE0\xB4\x80\xE0\xB8"
         "\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
     };
     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));
     }
   }
 
   // Create a SMP 2-byte string from a UTF-8 string literal.
   {
     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));
     }
   }
 
   // Create a 2-byte string from UTF-8 encoded 2- and 4-byte
   // characters.
   {
     const char* src =
         "\xE0\xA8\x80\xE0\xAC\x80\xE0\xB0"
         "\x80\xE0\xB4\x80\xE0\xB8\x80\xE0"
         "\xBC\x80\xEA\x80\x80\xEB\x80\x80"
         "\xEC\x80\x80\xED\x80\x80\xEE\x80"
         "\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,
     };
     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));
     }
   }
 
   // Create a 2-byte string from UTF-8 encoded 1-, 2- and 4-byte
   // characters.
   {
     const char* src =
         "\x0A\x0B\x0D\x0C\x0E\x0F\xC2\xA0"
         "\xC2\xB0\xC3\x80\xC3\x90\xC3\xA0"
         "\xC3\xB0\xE0\xA8\x80\xE0\xAC\x80"
         "\xE0\xB0\x80\xE0\xB4\x80\xE0\xB8"
         "\x80\xE0\xBC\x80\xEA\x80\x80\xEB"
         "\x80\x80\xEC\x80\x80\xED\x80\x80"
         "\xEE\x80\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[] = {
       0x000A, 0x000B, 0x000D, 0x000C, 0x000E, 0x000F, 0x00A0, 0x00B0,
       0x00C0, 0x00D0, 0x00E0, 0x00F0, 0x0A00, 0x0B00, 0x0C00, 0x0D00,
       0x0E00, 0x0F00, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000,
       0xD828, 0xDC00, 0xD82c, 0xDC00, 0xD834, 0xDC00, 0xD838, 0xDC00,
       0xD83c, 0xDC00,
     };
     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));
     }
   }
 }
 
 
 TEST_CASE(ExternalOneByteString) {
   uint8_t characters[] = { 0xF6, 0xF1, 0xE9 };
   intptr_t len = ARRAY_SIZE(characters);
 
   const String& str =
@@ skipping 580 matching lines @@
   const char* source_chars = "This will not compile.";
   const String& url = String::Handle(String::New(url_chars));
   const String& source = String::Handle(String::New(source_chars));
   const Script& script = Script::Handle(Script::New(url,
                                                     source,
                                                     RawScript::kSourceTag));
   EXPECT(!script.IsNull());
   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));
 }
 
 
 TEST_CASE(Context) {
   const int kNumVariables = 5;
   const Context& parent_context = Context::Handle(Context::New(0));
   EXPECT_EQ(parent_context.isolate(), Isolate::Current());
   const Context& context = Context::Handle(Context::New(kNumVariables));
   context.set_parent(parent_context);
   const Context& check_parent_context = Context::Handle(context.parent());
@@ skipping 219 matching lines @@
   Code& code = Code::Handle(Code::FinalizeCode(
       *CreateFunction("Test_EmbedStringInCode"), &_assembler_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   typedef uword (*EmbedStringCode)();
   uword retval = reinterpret_cast<EmbedStringCode>(instructions.EntryPoint())();
   EXPECT((retval & kSmiTagMask) == kHeapObjectTag);
   String& string_object = String::Handle();
   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]));
   }
 }
 
 
 // Test for Embedded Smi object in the instructions.
 TEST_CASE(EmbedSmiInCode) {
   extern void GenerateEmbedSmiInCode(Assembler* assembler, intptr_t value);
   const intptr_t kSmiTestValue = 5;
   Assembler _assembler_;
   GenerateEmbedSmiInCode(&_assembler_, kSmiTestValue);
@@ skipping 790 matching lines @@
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak1.key() == Object::null());
   EXPECT(weak1.value() == Object::null());
   EXPECT(weak2.key() == Object::null());
   EXPECT(weak2.value() == Object::null());
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart