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.CharAt(0));
+  EXPECT_EQ(ToUChar('e'), str.CharAt(1));
+  EXPECT_EQ(ToUChar('l'), str.CharAt(2));
+  EXPECT_EQ(ToUChar('l'), str.CharAt(3));
+  EXPECT_EQ(ToUChar('o'), str.CharAt(4));
+  EXPECT_EQ(ToUChar(' '), str.CharAt(5));
+  EXPECT_EQ(ToUChar('W'), str.CharAt(6));
+  EXPECT_EQ(ToUChar('o'), str.CharAt(7));
+  EXPECT_EQ(ToUChar('r'), str.CharAt(8));
+  EXPECT_EQ(ToUChar('l'), str.CharAt(9));
+  EXPECT_EQ(ToUChar('d'), str.CharAt(10));
+  EXPECT_EQ(ToUChar('!'), str.CharAt(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.CharAt(0));
+  EXPECT_EQ(ToUChar('e'), str2.CharAt(1));
+  EXPECT_EQ(ToUChar('s'), str2.CharAt(2));
+  EXPECT_EQ(ToUChar('c'), str2.CharAt(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"));
@@ skipping 28 matching lines @@
 
   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(ToUChar('H'), two_str.CharAt(0));
   EXPECT_EQ(256, two_str.CharAt(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(ToUChar('l'), sub2.CharAt(0));
+  EXPECT_EQ(ToUChar('o'), sub2.CharAt(1));
   EXPECT_EQ(256, sub2.CharAt(2));
-  EXPECT_EQ('!', sub2.CharAt(3));
+  EXPECT_EQ(ToUChar('!'), sub2.CharAt(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 int32_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(ToUChar('C'), four_str.CharAt(0));
   EXPECT_EQ(0xFF, four_str.CharAt(1));
-  EXPECT_EQ('h', four_str.CharAt(2));
+  EXPECT_EQ(ToUChar('h'), four_str.CharAt(2));
   EXPECT_EQ(0xFFFF, four_str.CharAt(3));
-  EXPECT_EQ('a', four_str.CharAt(4));
+  EXPECT_EQ(ToUChar('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('r'), four_str.CharAt(7));
 
   // Create a 1-byte string from an array of 2-byte elements.
   {
     const uint16_t char16[] = { 0x00, 0x7F, 0xFF };
     const String& str8 = String::Handle(String::New(char16, 3));
     EXPECT(str8.IsOneByteString());
     EXPECT(!str8.IsTwoByteString());
     EXPECT_EQ(0x00, str8.CharAt(0));
     EXPECT_EQ(0x7F, str8.CharAt(1));
     EXPECT_EQ(0xFF, str8.CharAt(2));
   }
 
   // Create a 1-byte string from an array of 4-byte elements.
   {
-    const uint32_t char32[] = { 0x00, 0x1F, 0x7F };
+    const int32_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));
   }
 
   // Create a 2-byte string from an array of 4-byte elements.
   {
-    const uint32_t char32[] = { 0, 0x7FFF, 0xFFFF };
+    const int32_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));
   }
 }
 
 
@@ skipping 324 matching lines @@
     EXPECT_EQ(two_one_two_len, str6.Length());
     EXPECT(str6.Equals(two_one_two, two_one_two_len));
   }
 
   // Concatenated emtpy and non-empty strings built from 4-byte elements.
   {
     const String& str1 = String::Handle(String::New(""));
     EXPECT(str1.IsOneByteString());
     EXPECT_EQ(0, str1.Length());
 
-    uint32_t four[] = { 0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1 };
+    int32_t four[] = { 0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1 };
     intptr_t four_len = sizeof(four) / sizeof(four[0]);
     intptr_t expected_len = (four_len * 2);
     const String& str2 = String::Handle(String::New(four, four_len));
     EXPECT(str2.IsTwoByteString());
     EXPECT_EQ(expected_len, str2.Length());
 
     // Concat
 
     const String& str3 = String::Handle(String::Concat(str1, str2));
     EXPECT_EQ(expected_len, str3.Length());
@@ skipping 24 matching lines @@
     EXPECT_EQ(expected_len, str6.Length());
     EXPECT(str6.Equals(str2));
 
     const Array& array3 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array3.Length());
     array3.SetAt(0, str2);
     array3.SetAt(1, str1);
     array3.SetAt(2, str2);
     const String& str7 = String::Handle(String::ConcatAll(array3));
     EXPECT(str7.IsTwoByteString());
-    uint32_t fourfour[] = { 0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1,
-                            0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1 };
+    int32_t fourfour[] = { 0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1,
+                           0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1 };
     intptr_t fourfour_len = sizeof(fourfour) / sizeof(fourfour[0]);
     EXPECT_EQ((fourfour_len * 2), str7.Length());
     const String& fourfour_str =
         String::Handle(String::New(fourfour, fourfour_len));
     EXPECT(str7.Equals(fourfour_str));
   }
 
   // Concatenate non-empty strings built from 4-byte elements.
   {
-    const uint32_t one[] = { 0x105D0, 0x105D9, 0x105D9, 0x105DF };
+    const int32_t one[] = { 0x105D0, 0x105D9, 0x105D9, 0x105DF };
     intptr_t one_len = sizeof(one) / sizeof(one[0]);
     const String& onestr = String::Handle(String::New(one, one_len));
     EXPECT(onestr.IsTwoByteString());
     EXPECT_EQ((one_len *2), onestr.Length());
 
-    const uint32_t two[] = { 0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9 };
+    const int32_t two[] = { 0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9 };
     intptr_t two_len = sizeof(two) / sizeof(two[0]);
     const String& twostr = String::Handle(String::New(two, two_len));
     EXPECT(twostr.IsTwoByteString());
     EXPECT_EQ((two_len * 2), twostr.Length());
 
     // Concat
 
     const String& str1 = String::Handle(String::Concat(onestr, twostr));
     EXPECT(str1.IsTwoByteString());
-    const uint32_t one_two[] = { 0x105D0, 0x105D9, 0x105D9, 0x105DF,
-                                 0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9 };
+    const int32_t one_two[] = { 0x105D0, 0x105D9, 0x105D9, 0x105DF,
+                                0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9 };
     intptr_t one_two_len = sizeof(one_two) / sizeof(one_two[0]);
     EXPECT_EQ((one_two_len * 2), str1.Length());
     const String& one_two_str =
         String::Handle(String::New(one_two, one_two_len));
     EXPECT(str1.Equals(one_two_str));
 
     const String& str2 = String::Handle(String::Concat(twostr, onestr));
     EXPECT(str2.IsTwoByteString());
-    const uint32_t two_one[] = { 0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9,
-                                 0x105D0, 0x105D9, 0x105D9, 0x105DF };
+    const int32_t two_one[] = { 0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9,
+                                0x105D0, 0x105D9, 0x105D9, 0x105DF };
     intptr_t two_one_len = sizeof(two_one) / sizeof(two_one[0]);
     EXPECT_EQ((two_one_len * 2), str2.Length());
     const String& two_one_str =
         String::Handle(String::New(two_one, two_one_len));
     EXPECT(str2.Equals(two_one_str));
 
     // ConcatAll
 
     const Array& array1 = Array::Handle(Array::New(2));
     EXPECT_EQ(2, array1.Length());
@@ skipping 13 matching lines @@
     EXPECT_EQ((two_one_len * 2), str4.Length());
     EXPECT(str4.Equals(two_one_str));
 
     const Array& array3 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array3.Length());
     array3.SetAt(0, onestr);
     array3.SetAt(1, twostr);
     array3.SetAt(2, onestr);
     const String& str5 = String::Handle(String::ConcatAll(array3));
     EXPECT(str5.IsTwoByteString());
-    const uint32_t one_two_one[] = { 0x105D0, 0x105D9, 0x105D9, 0x105DF,
-                                     0x105E6, 0x105D5, 0x105D5, 0x105D9,
-                                     0x105D9,
-                                     0x105D0, 0x105D9, 0x105D9, 0x105DF };
+    const int32_t one_two_one[] = { 0x105D0, 0x105D9, 0x105D9, 0x105DF,
+                                    0x105E6, 0x105D5, 0x105D5, 0x105D9,
+                                    0x105D9,
+                                    0x105D0, 0x105D9, 0x105D9, 0x105DF };
     intptr_t one_two_one_len = sizeof(one_two_one) / sizeof(one_two_one[0]);
     EXPECT_EQ((one_two_one_len * 2), str5.Length());
     const String& one_two_one_str =
         String::Handle(String::New(one_two_one, one_two_one_len));
     EXPECT(str5.Equals(one_two_one_str));
 
     const Array& array4 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array4.Length());
     array4.SetAt(0, twostr);
     array4.SetAt(1, onestr);
     array4.SetAt(2, twostr);
     const String& str6 = String::Handle(String::ConcatAll(array4));
     EXPECT(str6.IsTwoByteString());
-    const uint32_t two_one_two[] = { 0x105E6, 0x105D5, 0x105D5, 0x105D9,
-                                     0x105D9,
-                                     0x105D0, 0x105D9, 0x105D9, 0x105DF,
-                                     0x105E6, 0x105D5, 0x105D5, 0x105D9,
-                                     0x105D9 };
+    const int32_t two_one_two[] = { 0x105E6, 0x105D5, 0x105D5, 0x105D9,
+                                    0x105D9,
+                                    0x105D0, 0x105D9, 0x105D9, 0x105DF,
+                                    0x105E6, 0x105D5, 0x105D5, 0x105D9,
+                                    0x105D9 };
     intptr_t two_one_two_len = sizeof(two_one_two) / sizeof(two_one_two[0]);
     EXPECT_EQ((two_one_two_len * 2), str6.Length());
     const String& two_one_two_str =
         String::Handle(String::New(two_one_two, two_one_two_len));
     EXPECT(str6.Equals(two_one_two_str));
   }
 
   // Concatenate 1-byte strings and 2-byte strings.
   {
     const uint8_t one[] = { 'o', 'n', 'e', ' ', 'b', 'y', 't', 'e' };
@@ skipping 196 matching lines @@
   // 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 int32_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));
     }
   }
 
   // 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,
-                                  0xd835, 0xdc62, 0xd835, 0xdc63 };
+    const int32_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));
     }
   }
 
   // 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 int32_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));
     }
   }
 
   // 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 int32_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());
@@ skipping 113 matching lines @@
   EXPECT_EQ(nine.raw(), Symbols::New("Neun"));
   EXPECT_EQ(ten.raw(), Symbols::New("Zehn"));
 
   // Symbols from Strings.
   eins = String::New("Eins");
   EXPECT(!eins.IsSymbol());
   String& ein_symbol = String::Handle(Symbols::New(eins));
   EXPECT_EQ(one.raw(), ein_symbol.raw());
   EXPECT(one.raw() != eins.raw());
 
-  uint32_t char32[] = { 'E', 'l', 'f' };
-  String& elf = String::Handle(Symbols::New(char32, 3));
+  uint16_t char16[] = { 'E', 'l', 'f' };
+  String& elf = String::Handle(Symbols::New(char16, 3));
   EXPECT(elf.IsSymbol());
   EXPECT_EQ(elf.raw(), Symbols::New("Elf"));
+
+  uint16_t monkey_utf16[] = { 0xd83d, 0xdc35 };  // Unicode Monkey Face.
+  String& monkey = String::Handle(Symbols::New(monkey_utf16, 2));
+  EXPECT(monkey.IsSymbol());
+  EXPECT_EQ(monkey.raw(), Symbols::New("🐵"));
 }
 
 
 TEST_CASE(Bool) {
   const Bool& true_value = Bool::Handle(Bool::True());
   EXPECT(true_value.value());
   const Bool& false_value = Bool::Handle(Bool::False());
   EXPECT(!false_value.value());
 }
 
@@ skipping 455 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.CharAt(0));
+  EXPECT_EQ(ToUChar(':'), str.CharAt(7));
+  EXPECT_EQ(ToUChar('e'), str.CharAt(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.CharAt(0));
+  EXPECT_EQ(ToUChar('n'), str.CharAt(10));
+  EXPECT_EQ(ToUChar('.'), str.CharAt(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.CharAt(i) == static_cast<int32_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