Issue - 7123

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 547 matching lines @@
   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));
 
   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));
+  const String& two_str = String::Handle(String::FromUTF16(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));
   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));
 
   {
     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 int32_t four_chars[] = { 'C', 0xFF, 'h', 0xFFFF, 'a', 0x10FFFF, 'r' };
-  const String& four_str = String::Handle(String::New(four_chars, 7));
+  const String& four_str = String::Handle(String::FromUTF32(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));
 
   // 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));
+    const String& str8 = String::Handle(String::FromUTF16(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 int32_t char32[] = { 0x00, 0x1F, 0x7F };
-    const String& str8 = String::Handle(String::New(char32, 3));
+    const String& str8 = String::Handle(String::FromUTF32(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 int32_t char32[] = { 0, 0x7FFF, 0xFFFF };
-    const String& str16 = String::Handle(String::New(char32, 3));
+    const String& str16 = String::Handle(String::FromUTF32(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));
   }
 }
 
 
 TEST_CASE(StringFormat) {
@@ skipping 185 matching lines @@
   }
 
   // Concatenate empty and non-empty 2-byte strings.
   {
     const String& str1 = String::Handle(String::New(""));
     EXPECT(str1.IsOneByteString());
     EXPECT_EQ(0, str1.Length());
 
     uint16_t two[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
     intptr_t two_len = sizeof(two) / sizeof(two[0]);
-    const String& str2 = String::Handle(String::New(two, two_len));
+    const String& str2 = String::Handle(String::FromUTF16(two, two_len));
     EXPECT(str2.IsTwoByteString());
     EXPECT_EQ(two_len, str2.Length());
 
     // Concat
 
     const String& str3 = String::Handle(String::Concat(str1, str2));
     EXPECT(str3.IsTwoByteString());
     EXPECT_EQ(two_len, str3.Length());
     EXPECT(str3.Equals(str2));
 
@@ skipping 34 matching lines @@
                           0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
     intptr_t twotwo_len = sizeof(twotwo) / sizeof(twotwo[0]);
     EXPECT(str7.IsTwoByteString());
     EXPECT(str7.Equals(twotwo, twotwo_len));
   }
 
   // Concatenating non-empty 2-byte strings.
   {
     const uint16_t one[] = { 0x05D0, 0x05D9, 0x05D9, 0x05DF };
     intptr_t one_len = sizeof(one) / sizeof(one[0]);
-    const String& str1 = String::Handle(String::New(one, one_len));
+    const String& str1 = String::Handle(String::FromUTF16(one, one_len));
     EXPECT(str1.IsTwoByteString());
     EXPECT_EQ(one_len, str1.Length());
 
     const uint16_t two[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
     intptr_t two_len = sizeof(two) / sizeof(two[0]);
-    const String& str2 = String::Handle(String::New(two, two_len));
+    const String& str2 = String::Handle(String::FromUTF16(two, two_len));
     EXPECT(str2.IsTwoByteString());
     EXPECT_EQ(two_len, str2.Length());
 
     // Concat
 
     const String& one_two_str = String::Handle(String::Concat(str1, str2));
     EXPECT(one_two_str.IsTwoByteString());
     const uint16_t one_two[] = { 0x05D0, 0x05D9, 0x05D9, 0x05DF,
                                  0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
     intptr_t one_two_len = sizeof(one_two) / sizeof(one_two[0]);
@@ skipping 59 matching lines @@
 
   // 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());
 
     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));
+    const String& str2 = String::Handle(String::FromUTF32(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());
     EXPECT(str3.Equals(str2));
 
     const String& str4 = String::Handle(String::Concat(str2, str1));
@@ skipping 26 matching lines @@
     array3.SetAt(0, str2);
     array3.SetAt(1, str1);
     array3.SetAt(2, str2);
     const String& str7 = String::Handle(String::ConcatAll(array3));
     EXPECT(str7.IsTwoByteString());
     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));
+        String::Handle(String::FromUTF32(fourfour, fourfour_len));
     EXPECT(str7.Equals(fourfour_str));
   }
 
   // Concatenate non-empty strings built from 4-byte elements.
   {
     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));
+    const String& onestr = String::Handle(String::FromUTF32(one, one_len));
     EXPECT(onestr.IsTwoByteString());
     EXPECT_EQ((one_len *2), onestr.Length());
 
     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));
+    const String& twostr = String::Handle(String::FromUTF32(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 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));
+        String::Handle(String::FromUTF32(one_two, one_two_len));
     EXPECT(str1.Equals(one_two_str));
 
     const String& str2 = String::Handle(String::Concat(twostr, onestr));
     EXPECT(str2.IsTwoByteString());
     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));
+        String::Handle(String::FromUTF32(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());
     array1.SetAt(0, onestr);
     array1.SetAt(1, twostr);
     const String& str3 = String::Handle(String::ConcatAll(array1));
     EXPECT(str3.IsTwoByteString());
@@ skipping 16 matching lines @@
     array3.SetAt(2, onestr);
     const String& str5 = String::Handle(String::ConcatAll(array3));
     EXPECT(str5.IsTwoByteString());
     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));
+        String::Handle(String::FromUTF32(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 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));
+        String::Handle(String::FromUTF32(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' };
     intptr_t one_len = sizeof(one) / sizeof(one[0]);
-    const String& onestr = String::Handle(String::New(one, one_len));
+    const String& onestr = String::Handle(String::FromLatin1(one, one_len));
     EXPECT(onestr.IsOneByteString());
     EXPECT_EQ(one_len, onestr.Length());
     EXPECT(onestr.Equals(one, one_len));
 
     uint16_t two[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
     intptr_t two_len = sizeof(two) / sizeof(two[0]);
-    const String& twostr = String::Handle(String::New(two, two_len));
+    const String& twostr = String::Handle(String::FromUTF16(two, two_len));
     EXPECT(twostr.IsTwoByteString());
     EXPECT_EQ(two_len, twostr.Length());
     EXPECT(twostr.Equals(two, two_len));
 
     // Concat
 
     const String& one_two_str = String::Handle(String::Concat(onestr, twostr));
     EXPECT(one_two_str.IsTwoByteString());
     uint16_t one_two[] = { 'o', 'n', 'e', ' ', 'b', 'y', 't', 'e',
                            0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
@@ skipping 2105 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