Fix for issue 7089 (Symbols::New was not quite working correctly

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 250 matching lines @@
   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));
+      String::Handle(String::FromUTF8(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));
+  const String& dog_face =
+      String::Handle(String::FromUTF8(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));
+  const String& domino =
+      String::Handle(String::FromUTF8(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);
@@ skipping 214 matching lines @@
   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));
 
   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));
+  const String& str2 = String::Handle(String::FromUTF8(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));
 
   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));
+  const String& str8 = String::Handle(String::FromUTF8(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));
   const intptr_t kCharsIndex = 3;
   const String& sub1 = String::Handle(String::SubString(str8, kCharsIndex));
   EXPECT_EQ((kCharsLen - kCharsIndex), sub1.Length());
@@ skipping 998 matching lines @@
   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));
+  String& elf1 = String::Handle(Symbols::FromUTF16(char16, 3));
   int32_t char32[] = { 'E', 'l', 'f' };
-  String& elf2 = String::Handle(Symbols::New(char32, 3));
+  String& elf2 = String::Handle(Symbols::FromUTF32(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));
+  String& monkey = String::Handle(Symbols::FromUTF16(monkey_utf16, 2));
   EXPECT(monkey.IsSymbol());
   const char monkey_utf8[] = {0xf0, 0x9f, 0x90, 0xb5, 0};
   EXPECT_EQ(monkey.raw(), Symbols::New(monkey_utf8));
 
   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));
+  String& cat2 = String::Handle(Symbols::FromUTF16(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());
@@ skipping 1645 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