Fix Unicode issues in dart2js and dart2dart.

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/class_finalizer.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
@@ skipping 256 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 1240 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());
 
+  uint16_t char16[] = { 'E', 'l', 'f' };
+  String& elf1 = String::Handle(Symbols::New(char16, 3));
   int32_t char32[] = { 'E', 'l', 'f' };
-  String& elf = String::Handle(Symbols::New(char32, 3));
-  EXPECT(elf.IsSymbol());
-  EXPECT_EQ(elf.raw(), Symbols::New("Elf"));
+  String& elf2 = String::Handle(Symbols::New(char32, 3));
+  EXPECT(elf1.IsSymbol());
+  EXPECT(elf2.IsSymbol());
+  EXPECT_EQ(elf1.raw(), Symbols::New("Elf"));
+  EXPECT_EQ(elf2.raw(), Symbols::New("Elf"));
 }
 
 
+TEST_CASE(SymbolUnicode) {
+  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("🐵"));

[cshapiro, 2012/11/21 18:13:23]

Please do not put non-ASCII characters in the VM sources.  Escaped UTF-8 is
okay.

[erikcorry, 2012/11/22 12:42:15]

Done.

+
+  int32_t kMonkeyFace = 0x1f435;
+  String& monkey2 = String::Handle(Symbols::FromCharCode(kMonkeyFace));
+  EXPECT_EQ(monkey.raw(), monkey2.raw());
+
+  // Unicode cat face with tears of joy.
+  int32_t kCatFaceWithTearsOfJoy = 0x1f639;
+  String& cat = String::Handle(Symbols::FromCharCode(kCatFaceWithTearsOfJoy));
+
+  uint16_t cat_utf16[] = { 0xd83d, 0xde39 };
+  String& cat2 = String::Handle(Symbols::New(cat_utf16, 2));
+  EXPECT(cat2.IsSymbol());
+  EXPECT_EQ(cat2.raw(), cat.raw());
+}
+
+
 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());
 }
 
 
 TEST_CASE(Array) {
   const int kArrayLen = 5;
@@ skipping 1623 matching lines @@
   EXPECT_NE(test1.SourceFingerprint(), test3.SourceFingerprint());
   EXPECT_NE(test3.SourceFingerprint(), test4.SourceFingerprint());
   EXPECT_NE(test4.SourceFingerprint(), test5.SourceFingerprint());
   EXPECT_NE(test5.SourceFingerprint(), test6.SourceFingerprint());
   EXPECT_EQ(test6.SourceFingerprint(), test7.SourceFingerprint());
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart